No abstract

Hard real-time embedded systems have stringent timing constraints that must be met in order to ensure the correct functioning of the system. In many cases, these systems are composed of several CPU-bound tasks, which may need to rely on multiple processors, since just a single processor may not allow meeting all timing constraints. In order to deal with stringent constraints, specialized operating system kernels are often adopted in real-time embedded systems. However, the operating system usage may introduce significant overheads in execution time as well as in memory requirement. Software synthesis is an alternative approach to operating systems usage, since it can generate tailored code that satisfy: (i) functional, performance, and resource constraints; and (ii) other features such as scheduling, resource management, communication and synchronization. In this paper, a software synthesis approach based on a formalism, namely, time Petri nets, is presented in order to generate predictable scheduled code for hard real-time embedded systems with multiple processors.

In recent years, GPUs (Graphics Processing Units) have shown a significant advance of computational resources available for the use of non-graphical applications. The ability to solve problems involving parallel computing as well as the development of new architectures that supports this new paradigm, such as CUDA (Compute Unified Device Architecture), have encouraged the use of GPU for general purpose applications, especially in games. Some parallel tasks which were CPU (Central Processing Unit) based are being ported over to the GPU due to theirs superior performance. One of these tasks is the pathfinding of an agent over a game map, which has already achieved a better performance on GPU, but is still limited. This paper describes some optimizations to a GPU pathfinding implementation, addressing a larger work set (agents and nodes) with good performance.

Complex applications need powerful computers to achieve results in a valid time. However, such machines are very expensive and not always available. An alternative is the adoption of several simple, less powerful, and less expensive computers, which triggers the need for an adaptable framework that would support parallel and distributed execution in several environments and with different communication protocols. By executing in a heterogeneous environment, the user benefits from a higher number of machines. The framework we propose allows switching from a heterogeneous to a more specialized executing environment, if or when it is available. It supports both newcomers who can use existing default implementations to more quickly create applications of their own, and experienced programmers who, besides using existing framework abstractions and implementations, can also implement some parts to increase performance. In fact, the main objective is supporting researches, being acceptable to loose some performance when compared to a tailored, and harder to implement solution, still having a better performance when compared to a nonparallel approach.