Search

Geekbench is one of the most referenced cross-platform benchmarks in the mobile world. Most of its workloads are synthetic but some of them aim to simulate real-world behavior. In the mobile world, its microarchitectural behavior has been reported rarely since the hardware profiling features are limited to the public. As a popular mobile performance workload, it is hard to find Geekbench’s microarchitecture characteristics in mobile devices. In this paper, a thorough experimental study of Geekbench performance characterization is reported with detailed performance metrics. This study also identifies mobile system on chip (SoC) microarchitecture impacts, such as the cache subsystem, instruction-level parallelism, and branch performance. After the study, we could understand the bottleneck of workloads, especially in the cache sub-system. This means that the change of data set size directly impacts performance score significantly in some systems and will ruin the fairness of the CPU benchmark. In the experiment, Samsung’s Exynos9820-based platform was used as the tested device with Android Native Development Kit (NDK) built binaries. The Exynos9820 is a superscalar processor capable of dual issuing some instructions. To help performance analysis, we enable the capability to collect performance events with performance monitoring unit (PMU) registers. The PMU is a set of hardware performance counters which are built into microprocessors to store the counts of hardware-related activities. Throughout the experiment, functional and microarchitectural performance profiles were fully studied. This paper describes the details of the mobile performance studies above. In our experiment, the ARM DS5 tool was used for collecting runtime PMU profiles including OS-level performance data. After the comparative study is completed, users will understand more about the mobile architecture behavior, and this will help to evaluate which benchmark is preferable for fair performance comparison.

In an intelligent smart city like Sejong city in Korea, automatic and smart software is absolutely necessary for autonomous traffic and vehicles control systems. Therefore, these systems need to have an accurate and timely performance; otherwise, safety issues may arise. To resolve this, we propose our code visualization approach to adapt an object-oriented smart traffic control simulator, which analyzes Java code’s complexity and identifies bad codes against performance. To achieve an accurate performance, we must repeatedly perform refactoring until attaining a range of system-defined performances through effective code visualization. As a result, we enhance the code complexity of the cyber-physical system-based software to achieve the exact performance. With this approach, we expect to obtain an accurate performance and complexity improvement of the object-oriented traffic control simulator without significant power consumption.

Sometimes unclearly describing the requirement specifications of satisfied customer’s needs, means it may be difficult to develop the production of high-quality software systems. A persistent issue of requirement engineering is how to clearly understand the requirements of the large and complex software project, and also how to analyze them exactly. To solve this problem, we propose a linguistic analysis method based on the semantic analysis of the Fillmore’s textual approach. This method extracts use-cases from informal requirement specifications. For applied requirement engineering with this method, we suggest extracting a use-case diagram, as well as calculating the software effort estimation with the original use-case point (UCP). To simply explanations of our use-case extraction method, we use one example of a simple postal information system.

In the Fourth Industrial Revolution environment, plenty of automatic and smart software in diverse fields will come out, such as virtual reality/augmented reality (VR/AR), autonomous robots and vehicles, smart factoring, and so on. In Korea, especially, one important issue is the cyber−physical system (CPS), used for monitoring and controlling the smart and automatic system in a smart city. This kind of system, therefore, needs to have good performance; otherwise, it may not respond in time. To solve this, we propose a code visualization approach to reduce code complexity based on a static analysis, which identifies bad codes against performance. To ensure better performance, we make our queries identify performance degradation factors, store statically analyzed data into database (DB) tables, and visualize bad operation patterns. For performance improvement, we can refactor with them. As a result, we reduce the code complexity of CPS-based software to obtain good performance. With this approach, we expect to have better performance and a reduction in the complexity of CPS software without even power consumption.