Evaluation of Embedded Systems for Automotive Image Processing Trung Tin Duong Department of ECE Sungkyunkwan University, Korea tindt@skku.edu Jung Hwan Seo Department of ECE Sungkyunkwan University, Korea joygo0912@skku.edu Thi Dinh Tran Department of ECE Sungkyunkwan University, Korea dinhtt@skku.edu Byun Jin Young Department of ECE Sungkyunkwan University, Korea jinya@skku.edu Jae Wook Jeon * Department of ECE Sungkyunkwan University, Korea jwjeon@yurim.skku.ac.kr Abstract— With the emergence of industry 4.0, autonomous driving vehicles have become an exciting research topic in the science technology community. The driving system requires many complex algorithms that provide both accurate results and fast running times. However, the performance of these algorithms is usually limited to standard personal computer (PC) systems. Currently, the computation power of available embedded systems lags far behind that of a standard PC, even when compared to PCs with moderate capabilities. Hence, we present some benchmark results of several systems, including standard PCs, laptops, and embedded systems, for performing computer vision algorithms. We collected a set of algorithms that are commonly used in autonomous driving systems and then ran each of these on our selected systems. In this evaluation, we focused only on the processing time without concerning about the precision of the algorithm. The details of the testing algorithms and systems are provided in this report also. We believe that our experiment can provide practical information to people who aim to transfer their algorithm to an embedded system. Index Terms—autonomous driving system, embedded system, performance evaluation, computer vision. I. I NTRODUCTION Substantial changes are currently occurring in the automo- tive industry. Consequently, multiple vision-based algorithms, which can be applied in autonomous driving systems, have been developed recently [1]. However, most of these algo- rithms have been tested in theory-friendly environments (i.e., standard personal computers) [2], [3], [4] and these systems cannot be brought onto real vehicles. In contrast, on-board systems attached to vehicles are usually small and have less computation power compared to PCs, such as the embedded system mentioned in [5]. Accordingly, there is a large gap between theory and practice in terms of the execution time that should be considered when deploying the algorithm in real life applications. Thanks to the advancement of computing systems, the compu- tation power of standard PCs has been improved significantly. The appearance of powerful GPUs has led to the realization of complex and intense algorithms, such as deep learning [6]. Even so, transferring these techniques into embedded systems can be problematic [7]. So far, the only embedded system that is capable of hosting a GPU core is the system from the Jetson family - NVIDIA. In addition, due to the variety of deep learning frameworks, it is difficult to deploy the algorithm on multiple systems, even on standard PCs. Therefore, we do not evaluate deep learning-based algorithms in this experiment in order to allow for a fair comparison between embedded systems In this work, we evaluate how the processing time varies when running the same algorithm on numerous platforms. Complex (e.g., human or car detection) and basic (e.g., pre-processing filters) algorithms were chosen for the experiment. These source codes will be made available for download in the near future. The main purpose of this research is to illustrate the performance gap between running an algorithm on a standard PC system and deploying it on an embedded system. We hope that these analyses will help other researchers find suitable embedded systems when deploying their algorithms. This paper is organized as follows: In Section 2, we present a brief introduction of all the algorithms used in this experiment. Next, an overview of testing platforms is illustrated in Section 3. The detailed evaluation process, result, and analysis are presented in Section 4, while the conclusion and future work are discussed in Section 5. II. ALGORITHMS OVERVIEW Currently, there are multiple programming languages used in public algorithms. However, in order to bring them to fruition (i.e., make them executable in embedded systems), most of them need to be converted to C/C++ at first. Therefore, we decided to choose only source codes written in C/C++ for both simplicity and fair comparison. So far, these algorithms are usually built on the so-called powerful image processing library OpenCV [8], which can be compiled easily, even on an embedded system. The chosen algorithms vary in complexity, from basic to quite complex, and are commonly used for autonomous driving systems. Figure 1 illustrates a