Journal Article Architecture/OS Support for Embedded Multi-core Systems Get access Sung Woo Chung, Sung Woo Chung * 1Division of Computer and Communication Engineering, Korea University, Seoul 136-713, Korea *Corresponding author: swchung@korea.ac.kr, schung05@naver.com Search for other works by this author on: Oxford Academic Google Scholar Hsien-Hsin S. Lee, Hsien-Hsin S. Lee 2School of Electrical and Computer Engineering, Georgia Institute of Technology, Atlanta, GA 30332, USA Search for other works by this author on: Oxford Academic Google Scholar Woo Hyong Lee Woo Hyong Lee 3System LSI Division, Samsung Electronics, Yongin-City, Gyeonggi-Do 446-711, Korea Search for other works by this author on: Oxford Academic Google Scholar The Computer Journal, Volume 53, Issue 8, October 2010, Pages 1134–1135, https://doi.org/10.1093/comjnl/bxq041 Published: 22 April 2010 Article history Received: 23 March 2010 Revision received: 23 March 2010 Published: 22 April 2010

Load balancing has been known as an essential feature for enhancing the performance of distributed systems. For embedded systems, however, this is not always true since load balancing leads to lavish power consumption by fully utilizing all the embedded cores even for a small number of tasks. Furthermore, the previously proposed load unbalancing strategies do not concern much about the characteristics of the embedded system's real workload. In this paper, to resolve this problem, we propose a novel load unbalancing strategy based on the task characteristics: periodic and aperiodic. In the proposed strategy, the periodic tasks that are more likely to be executed repeatedly are concentrated on the minimum number of cores, whereas the aperiodic tasks that are not likely to occur again soon are distributed to the maximum number of cores. The experimental results on an ARM11MPCore test chip show that the proposed strategy reduces power consumption and mean waiting time of the aperiodic tasks by up to 26 percent and 82 percent, respectively, compared to the load balancing strategy. As compared to the aggressive load unbalancing strategy, the proposed strategy also reduces mean waiting time of the aperiodic tasks by 92 percent with similar power efficiency.

Because dedicated hardware implementation for sophisticated video processing algorithms, especially for H.264, are costly and inflexible, Samsung wants to establish a computing intensive processing platforms for Home/Mobile solution, capable of adapting to a range of specific applications and standards through reconfigurability. For this study, we experiment the PACT XPP for the reconfigurable architecture implementation. The XPP enables a software-based acceleration of streaming data-intensive tasks. By incorporating an array of processing elements with runtime reconfigurability capabilities, a software based, parallelize processing of critical data-intensive streaming tasks is achieved.

Some may claim that general-purpose computers are reconfigurable in the sense that functional units are reused for different computational tasks at different times, with multiplexers controlling the routing between these units. However, in this paper as well as in the research community at large, the term reconfigurable computing refers to systems where the hardware can be customized and changed periodically to execute different tasks on the same hardware. In this paper we survey the reconfigurable computing landscape and make some recommendations. The landscape can be partitioned into two parts - one that is spearheaded by University research and the other that is taking shape in the industry. We describe one example from each, and provide a comparison of some reconfigurable architectures. We conclude by making some recommendations about the architectures, software tools, and applications of reconfigurable computing.

Dynamic memory management has been a high cost component in many software systems. A study has shown that memory intensive C programs can consume up to 30% of the program run time in memory allocation and liberation. Especially, in C++ programs, they tend to have object creation and deletion prolifically. C++ memory allocation rate can be as much as 10 times higher than the comparable applications written in C. Despite the importance of dynamic memory management in C++, there exist few software tools to study dynamic memory in C++. This paper introduces a tracing tool, called mtrace ++, to study the dynamic memory allocation behavior in C++ programs. Mtrace ++ is a source code level instrumented tracing tool which produces records of allocation and deallocation information. The allocation information contains size, type and path. The allocation paths may lead to indirect memory allocation. The collected traced data is analyzed by stat. Stat produces concise information from the traced data. Mtrace ++ provides extended functionalities which include measuring life-spans and detecting memory leaks. With limited overheads, mtrace ++ can help programmers to solve dynamic memory problems with affordable cost.

Many C++ studies show that dynamic memory management is one of the most expensive components in many software systems. C++ programs tend to carry out object creation and deletion prolifically. As a result, dynamic memory management can consume up to 30% of the program execution time in C++. In many cases, programmers need automatic dynamic memory management to free them from the problem of having to manage the C++'s large number of memory invocations. Unlike other object-oriented languages, C++ does not contain an automatic memory management policy among its language features. This paper presents a garbage collection strategy, called GC++, which collects garbage automatically with high speed of object allocation/deallocation. This high speed allocation/deallocation come from the utilization of memory allocation/deallocation behavior.The C++ allocation/deallocation patterns are determined experimentally in this paper. The proposed scheme is made feasible by minimizing memory allocation/deallocation calls and reusing objects based on other empirical investigations. To implement GC++, we applied the technique of Smart Pointer, which is one of the standard template containers. Our allocation scheme is simple and fast, since it requires no splitting and coalescing, and reduces the number of malloc() calls. It maintains its own free-list, which is used for object-reuse. Our scheme is purely source-code oriented and built on the top of the normal C++ memory manager. Therefore, this approach is portable, can be applied with existing code and is safe to use with different memory managers.

Recently, the importance of dynamic memory management has been increased significantly as there is a growing number of development in object-oriented programs. Many studies show that dynamic memory management is one of the most expensive components in many software systems. It can consume up to 30% of the program execution time. Especially, in C++ programs, it tends to have object creation and deletion prolifically. These objects tend to have short life-spans. This paper describes an integrated study of the C++'s memory allocation behavior, a memory tracing tool and memory managements based on the empirical study of C++ programs. First, this paper summarizes the hypothesis of situations that invoke the dynamic memory management explicitly and implicitly. They are: constructors, copy constructors, overloading assignment operator=, type conversions and application specific member functions. Second, a dynamic memory tracing tool, called mtrace++, is introduced to study the dynamic memory allocation behavior in C++ programs. Third, a dynamic memory allocation strategy, called O-Reuse, to reuse the allocated objects to speed up the object management. At the later part of this paper, an automatic dynamic memory management, called GC++, is discussed. GC++ collects unreferenced objects automatically with high speed of allocation/deallocation processes. The performance gains of O-Reuse and GC++ are come from the utilization of memory allocation/deallocation behavior.

The importance of dynamic memory management has increased significantly as there is a growing number of developments in object-oriented programs. Many studies show that dynamic memory management is one of the most expensive components of many software systems. It can consume up to 30% of the program execution time. Object-Oriented Programming (OOP) language systems tend to perform object creation and deletion prolifically. An empirical study has shown that C++ programs can have ten times more memory allocation and deallocation than comparable C programs. However, the allocation behavior of C++ programs is rarely reported. In this study, we attempted to locate where the dynamic memory allocations are coming from and report an empirical study of the allocation behavior of C++ programs. To do the experiment, we introduce a dynamic memory tracing tool, called Mtrace++, to study the memory allocation behavior in C++. Mtrace++ is a source code level instrumented tracing tool that produces records of allocation and deallocation information. Using Mtrace++, the C++ allocation patterns are studied thoroughly. After we identify the allocation behavior, we discuss a new high-performance memory management strategies, which were developed based on our empirical investigations. The goals for the strategies are fast allocation, fast deallocation, maximizing portability and space conservation.

The object-oriented programming (OOP) language systems tend to perform object creation and deletion prolifically. An empirical study has shown that C++ programs can have 10 times more memory allocation and deallocation than comparable C programs. However, the allocation behavior of C++ programs is rarely reported. This paper attempts to locate where the dynamic memory allocations are coming from and report an empirical study of the allocation behavior of C++ programs. Firstly, this paper summarizes the hypothesis of situations that invoke the dynamic memory management explicitly and implicitly. They are: constructors, copy constructors, overloading assignment operator=, type conversions and application-specific member functions. Secondly, the development of a source code level tracing tool is reported as a procedure to investigate the hypothesis. Most of the five C++ programs traced are real-world applications. Thirdly, allocation patterns, object size and age distribution are summarized. Among other things, we found that objects tend to have a very short life-span, and most of them are created through constructors and copy constructors. With these findings, we may improve the performance of dynamic memory management through, a profile-based strategy or reusing objects.

The importance of dynamic memory management has increased significantly as there is a growing number of developments in object-oriented programs. Many studies show that dynamic memory management is one of the most expensive components in many software systems. In C++ programs especially, it tends to have prolific object creation and deletion. These objects tend to have short life-spans. This paper presents a dynamic memory allocation strategy to reuse these objects to speed up the object management. This object reuse scheme is implemented through the overloading C++ operators, new and delete. The C++ allocation patterns are studied thoroughly in this paper. Over 90% of objects are not bigger than 512 bytes and allocated prolifically. The proposed scheme is made feasible by reuse of these small objects. Our allocation scheme is simple and fast because it requires no splitting and no coalescing, and reduces the number of malloc() calls. It maintains its own free-list which is used for object reuse. The experimented results, based on the proposed allocation scheme, show that allocation speed is increased up to four times compared to other well-known algorithms. Our scheme is purely source-code oriented and built on top of malloc. Therefore, this approach is portable for application to existing code and safe to use with different mallocs.

Dynamic memory management has been a high cost component in many software systems. Studies have shown that memory intensive C programs can consume up to 30% of the program runtime in memory allocation and liberation. The OOP language system tends to perform object creation and deletion prolifically. An empirical study shown that C++ programs can have ten times more memory allocation and deallocation than comparable C programs. However, the allocation behavior of C++ programs is rarely reported. This paper attempts to locate where the dynamic memory allocations are coming from and report an empirical study of dynamic memory invocations in C++ programs. Firstly, this paper summarizes the hypothesis of situations that invoke the dynamic memory management explicitly and implicitly. They are: constructors, copy constructors, overloading assignment operator=, type conversions and application specific member functions. Secondly, the development of a source code level tracing tool is reported as the procedure to investigate the hypothesis. Thirdly, results include behavioral patterns of memory allocations. With these patterns, we may increase the reusability of the resources. For example, a profile-based strategy can be used to improve the performance of dynamic memory management. The C++ programs that were traced include Java compiler, CORBA compliant and visual framework

Dynamic memory management has been a high cost component in many software systems. A study has shown that memory intensive C programs can consume up to 30% of the program run time in memory allocation and liberation. Especially, in C++ programs, they tend to have object creation and deletion prolifically. C++ memory allocation rate can be as much as ten times higher than the comparable applications written in C. Despite the importance of dynamic memory management in C++, there exist few software tools to study dynamic memory in C++. This paper introduces a tracing tool, called mtrace++, to study the dynamic memory allocation behavior in C++ programs. Mtrace++ is a source code level instrumented tracing tool, which produces records of allocation and deallocation information. Mtrace++ identifies originations of allocated memories and life spans of objects. With limited overheads, mtrace++ can help programmers to solve dynamic memory problems with affordable cost.