Search

High performance and high power efficiency are two mandatory constraints for multi-core systems in order to successfully handle the most recent applications in several fields, e.g. image processing and communication standards. Nowadays, hardware accelerators are often used along with several processing cores to achieve the desired performance while keeping high power efficiency. However, such systems impose an increased programming complexity due to the lack of software standards that supports heterogeneity, frequently leading to custom solutions. On the other hand, implementing a standard software solution for embedded systems might induce significant overheads. This work presents a hardware mechanism in co-design with a standard programming interface (API) for embedded systems focusing to decrease overheads imposed by software implementation while increasing programmability and communication performance. The results show gains of up to 97% in latency and an increase of 40 times in throughput for synthetic traffics and an average decrease of 95% in communication time for an image processing application.

The Multicore Communications API (MCAPI) is a new message-passing API that was released by the Multicore Association. MCAPI provides an interface designed for closely distributed embedded systems with multiple cores on a chip and/or chips on a board. Similar to parallel programs in other domains, debugging MCAPI programs is a challenging task due to their nondeterministic behavior. In this article we present a tool that is capable of deterministically replaying MCAPI program executions, which provides valuable insight for MCAPI developers in case of failure.

Multicore processor designs have become increasingly popular for embedded applications in recent years, but diversified inter-core communication mechanisms have led to the difficulties in software development, integration and migration. A unified, portable, and efficient inter-core communication mechanism would have helped reduce these difficulties significantly, but such a solution did not exist today. We proposed a scheme called MSG, which provides users with a set of essential message-passing programming interfaces adopted from MPI and MCAPI, including blocking and non-blocking point-to-point communications, one-sided communications, and collective operations. We experimented and evaluated our design methodology with case studies on two heterogeneous multicore platforms: IBM CELL and ITRI PAC DUO. On the CELL platform, our MSG library fitted in the 256KB local memory on each individual processor core and outperformed two existing communication libraries, DaCS and CML. On the second case study, we were able to port MSG onto the PAC DUO platform within two weeks upon receiving the platform. With a systematic approach, we showed how optimizations could be done to improve the performance of the MSG libraries. Hopefully, our experiences help the design and development of communication libraries for existing and future multicore platforms.

The increasing complexity in the development of embedded system is raising the need of system modularization, parallelization and component portability. High-level languages such as UML are clearly oriented to solve these needs, but implementation flows are usually highly dependent on platform details. Different platform-agnostic APIs such as MPI or MCAPI have appeared to increase the application independence from the executive HW. Nevertheless, the gap between the high-level models and the final system implementations is still too large. In this context, this paper presents a methodology for automating system deployment of component-based systems. The process starts from a high level description based on UML/MARTE, including complex channel semantics and provides automatic code generation for interconnection and deployment of system components based on MCAPI. This automatic process enables exploring different possibilities both in the component allocation and in the resulting concurrency, involving low designer effort.

This paper presents an implementation of Multicore Communications API (MCAPI), with focus on portability, stability, and simplicity of the design. The main motivation for the implementation is instability of other publicly available implementations. The developed implementation utilizes POSIX message queues, that is an easily portable interface and readily compatible with MCAPI. The performance was measured as latency and transfer rate of the API. The measurement platforms were a x86-64 PC and a development board featuring an ARM processor. A MCAPI implementation was used as reference for comparison. PMQ-MCAPI is much more stable and easily usable than other MCAPI implementations publicly available for PC. When transfer size was between 1–8 KiB, latency of transfers between cores was between 9–15 µs and transfer rate 500–5000 MBps. This translates to 27 000–45 000 cycles and 0.16–1.67 bytes per cycle. CPU and especially performance of its cache were concluded as the most important factors contributing to the performance. In comparison to the reference, latency of the implementation was 1/8 at best, while transfer rate was up to 35x.

The increasing complexity in the development of embedded system applications is necessitating system modularization, parallelization and component portability. Finding the best solution to combine component reuse and platform optimization is not an easy and straightforward task, especially when considering the different APIs supported to provide communication and concurrency on the different boards. Thus, in order to reduce designer effort, the development of automatic synthesis tools operating from high level models is emerging. In this context, this paper presents a methodology for automating system deployment on different platforms supporting distinct APIs. The process starts from a high-level description based on UML/MARTE and provides automatic code generation for interconnection and deployment of system components. This automatic process enables exploration of different possibilities both in the component allocation and in the resulting concurrency, requiring only minimal designer effort. Different APIs such as POSIX, OpenMP, OpenStream, TCP-IP and MCAPI are covered to provide the required flexibility for platform support and reuse.

Multicore software development is growing in importance and applicability in many areas of embedded systems from automotive to networking, to wireless base stations. This chapter is a summary of key sections of the recently released Multicore Programming Practices (MPP) from the Multicore Association (MCA). The MPP standardized “best practices” guide is written specifically for engineers and engineering managers of companies considering or implementing a development project involving multicore processors and favoring use of existing multicore technology. There is an important need to better understand how today’s C/C++ code may be written to be “multicore ready”, and this was accomplished under the influence of the MPP working group. The guide will enable you to (a) produce higher-performing software; (b) reduce the bug rate due to multicore software issues; (c) develop portable multicore code which can be targeted at multiple platforms; (d) reduce the multicore programming learning curve and speed up development time; and (e) tie into the current structure and roadmap of the Multicore Association’s API infrastructure.

FPGAs are traditionally designed with RTL-level IP-block descriptions. Many FPGA designs include several synthesizable processors and SW executables are mapped to them after a separate software development process. The tools help connecting physical blocks together and typically provide a board support package for SW development to access HW from the application code. The designer is still responsible of carefully planning how the applications on multiple cores communicate, which is getting the more difficult the more cores and other IP blocks are introduced. We apply Multicore Association Communications API (MCAPI) to implement hardware independent communication mechanism between the applications. The benefit is a unified programming API to different processor and operating system types, but also for hardware IP-blocks that the cores can access. We introduce MCAPI and show a case study of a simple video encoder with and without MCAPI abstraction. Porting an application function takes 3 hours with MCAPI and 5 without, i.e. 40% reduction. However, the overhead from MCAPI is increase memory footprint by 25 KB and effect on the video encoder performance -22% compared to non-MCAPI case.

IP-XACT, the recent IEEE1685 standard, defines metadata format for IP packing and integration in System-on-Chip designs. It was originally proposed for hardware descriptions, but we have extended it for software, HW/SW mappings and application communication abstraction. The latter is realized with Multicore Association MCAPI that is a lightweight message passing interface. In this paper we present as a work-in-progress how we utilize all these to deploy and move application tasks between different platforms for FPGA prototyping, execution acceleration or verification. The focus is on the metadata format since it is a foundation for automation and tool development. The design flow is illustrated with two case studies: A motion JPEG encoder and a 12-node workload model of video object plane decoder (VOPD). These are deployed to PC and Altera and Xilinx FPGA boards in five variations. The results are reported as the deployment time for both non-recurring and deployment specific tasks. Setting up a new deployment is a matter of hours when there is an IP-XACT library of HW and SW components.

Multi-core processor technology has been applied to the processors in embedded systems as well as in ordinary PC systems. In multi-core embedded processors, however, a processor may consist of heterogeneous CPU cores that are not configured with a shared memory and do not have a communication mechanism for inter-core communication. MCAPI is a highly portable API standard for providing inter-core communication independent of the architecture heterogeneity. In this paper, we extend the current MCAPI to a multi-chip in a distributed memory configuration and propose its portable implementation, named XMCAPI, on a commodity network stack. With XMCAPI, the inter-core communication method for intra-chip cores is extended to inter-chip cores. We evaluate the XMCAPI implementation, xmcapi/ip, on a standard socket in a portable software development environment.

Key challenge for embedded system companies is management of product configurations over lifecycle. Either new functionality is implemented on an old platform, legacy code on a new one, or both at the same time. We propose Kactus2, a product integration environment suitable for small and mid-size enterprises (SME) utilizing FPGAs. We combine IP-XACT for HW integration and Multicore Association Communications API (MCAPI) for SW integration. The programmer has a uniform view of the system as MCAPI nodes regardless of their implementation in SW or HW. Kactus2 is a work-in-progress open source project implemented in C++ and QT 4.7 currently containing over 40k lines of code and gSOAP as TGI IP-XACT interface.

The design and implementation of an application programming interface (API) is a trade-off between abstraction it provides and overheads it causes. This paper presents an implementation of Multicore Communications API (MCAPI) on a heterogeneous platform consisting of FPGA-based multiprocessor system-on-chip (MPSoC) connected via PCIe to an external CPU board. The purpose is to provide a unified programming API to different processor and OS types as well as hardware IP-blocks. MCAPI is shown to meet these requirements. We show the MCAPI transport implementation on three processors and two buses, measure the overhead cost, and analyze the effort required to port an application from a PC to the MPSoC. The measured library memory footprint is less than 25KB and the roundtrip communication latency is diminishing low - only few dozen clock cycles - compared to non-MCAPI implementation.

In the recent years, multicore processor designs have become increasingly popular for embedded applications, but diversified inter-core communication mechanisms have led to the difficulties in software development, integration and migration. A unified, portable, and efficient inter-core communication mechanism would have helped reduce these difficulties significantly, but such a solution did not exist today. We proposed a scheme called MSG, which provides users with a set of essential message-passing programming interfaces adopted from MPI and MCAPI, including blocking and non-blocking point-to-point communications, one-sided communications, and collective operations. We experimented and evaluated our design methodology with the case study on the IBM CELL, a popular heterogeneous multicore platform. On the CELL platform, our MSG library fitted in the 256KB local memory on each individual processor core and outperformed two existing communication libraries, DaCS and CML. With a systematic approach, we showed how optimization could be done on the CELL platform to improve the performance of the MSG library. Hopefully, our experiences help the design and development of communication libraries for existing and future multicore platforms and embedded applications.

We present a dynamic direct code verification tool called MCC (MCAPI Checker) for applications written in the newly proposed Multicore Communications API (MCAPI). MCAPI provides both message passing and threading constructs, making the concurrent programming involved in MCAPI application development a non-trivial challenge. MCC intercepts MCAPI calls issued by user applications. Then, using a verification scheduler, MCC orchestrates a dependency directed replay of all relevant thread interleavings. This paper presents the technical challenges in handling MCC's non-blocking constructs. This is the first dynamic model checker for MCAPI applications, and as such our work provides designers the opportunity to use a formal design tool in verifying MCAPI applications and evaluating MCAPI itself in the formative stages of MCAPI.