Whether one or multiple hardware execution units are activated (i.e. CPU cores), invalid resource sharing, notably due to simultaneous accesses, proves to be problematic as it can yield to unexpected runtime behaviors with negative implications such as security or safety issues. The growing interest for off-the-shelf multi-core architectures in sensitive applications motivates the need for safe resources sharing. If critical sections are a well-known solution from imperative and non-temporized programming models, they fail to provide safety guarantees. By leveraging the time-triggered programming model, this paper aims at enforcing that identified critical windows of computations can never be simultaneously executed. We achieve this result by determining, before an application is compiled, the exact dates during which a task accesses a shared resource, which enables the off-line validation of non-simultaneity constraints.

In this work, we investigate the accuracy of attitude estimation solutions based on inertial/magnetic sensors in the context of motorcycle trajectory reconstruction. We propose a comparative study and analysis of a number of quaternion based attitude-filtering methods. We conduct an experimental study using a multi-sensor platform with a precise ground truth obtained with a GPS RTK. We quantify the error in the motorcycle trajectory estimation obtained with each method and we discuss the obtained results.

Pointer aliasing still hinders compiler optimizations. The ISO C standard 99 has added the restrict keyword that allows programmer to specify non-aliasing as an aid to the compiler's optimizer. The task of annotating pointers with the restrict keyword is still left to the programmer and this task is, in general, tedious and prone to errors. Scalar replacement is an optimization widely used by compilers. In this paper, we present two new Frama-C plug-ins, RECKA for automatic annotation of CUDA kernels arguments with the restrict keyword, and RPromF for scalar replacement in OpenACC and OpenMP 4.0/4.5 codes for GPU. More specifically, RECKA works as follows: (i) an alias analysis is performed on CUDA kernels and their callers; (ii) if not found any alias then CUDA kernels are cloned, the clones are renamed and their arguments are annotated with the restrict qualifier; and (iii) instructions are added to kernels call sites to perform at runtime a less-than check analysis on kernel actuals parameters and determine if the clone must be called or the original one. RPromF includes five main steps: (i) OpenACC/OpenMP offloading regions are identified; (ii) functions containing these offloading codes and their callers are analyzed to check that there is no alias; (iii) if there is no alias then the offloading codes are cloned; (iv) clone's instructions are analyzed to retrieve data reuse information and perform scalar replacement; and instructions are added to be able to use the optimized clone whenever possible. We have evaluated the two plug-ins on PolyBench benchmark suite. The results show that both scalar replacement and the usage of restrict keyword are effective for improving the overall performance of OpenACC, OpenMP 4.0/4.5 and CUDA codes.

The development of Advanced Driver Assistance Systems (ADAS), such as pedestrian detection, requires real-time update rates at high image resolution. Hopefully, heterogeneous architectures with high computing performance have been developed for this purpose. To benefit from this hardware performance, different programming languages and acceleration frameworks have been developed. OpenVX framework provides a graph-based execution model to program image processing algorithms on heterogeneous platforms. In this work, we investigate OpenVX optimizations for computer vision applications. We examine how this framework responds to different data access patterns. We test three important optimizations of OpenVX: kernels merge, data tiling and parallelization via OpenMP. The contribution and the impact of each optimization on different data access pattern are explained.

In this paper we present a study of using an heterogeneous architecture to implement the graph-based SLAM algorithm. The study aims to investigate the performances of an ARM-GPU based architecture by offloading some critical compute-intensive tasks of the algorithm to the integrated GPU.

The graph-based SLAM (Simultaneous Localization and Mapping) method uses a graph to represent and solve the SLAM problem. The SLAM allows building a map of an unknown environment and simultaneously localizing the robot on this map. This paper presents a temporal analysis of the 3D graph-based SLAM method. We also propose an efficient implementation, on an OMAP embedded architecture, which is a widely used open multimedia applications platform. We provide an optimized data structure and an efficient memory access management to solve the nonlinear least squares problem related to the algorithm. The algorithm takes advantage of the Schur complement to reduce the execution time. We will present an optimized implementation of this task. We also take advantage of the multi-core architecture to parallelize the algorithm. To evaluate our implementation, we will compare the computational performances to the well known framework g2o. This work aims to demonstrate how optimizing data structure and multi-threading can decrease significantly the execution time of the graph-based SLAM on a low-cost architecture dedicated to embedded applications.

An autonomous robot has to localize itself in an unknown area. Simultaneous Localization and Mapping (SLAM) allows for a robot to build a map of an unknown environment and localize simultaneously itself on this map. Graph-based SLAM methods use a graph to represent and solve the SLAM problem. This paper presents an optimized implementation of the incremental 3D graph-based SLAM on an OMAP architecture used as open multimedia applications platform. This implementation uses an optimized data structure and an efficient memory access management to solve the nonlinear least squares problem related to the algorithm. It takes also advantage of the multi-core architecture to parallelize the algorithm. To evaluate our implementation, we will evaluate the processing times of the implemented algorithm compared to those of the well known framework g2o.

To increase the autonomy of robots, it is necessary to have a precise and guaranteed localization. We propose a SLAM algorithm based on interval analysis and constraints propagation. The problem is casted into a constraint satisfaction which is solved in a guaranteed way via Interval Analysis. We define a new bounded landmark parameterization and an initialization method for monocular camera. Finally, we introduce the post-localization process which improves the localization accuracy using the future observations. Both simulations and experiments show guaranteed and consistent results of CP-SLAM.

Research community has developed numerous SLAM (Simultaneous Localization And Mapping) algorithms in the last ten years. These algorithms are widely used by autonomous robots operating in unknown environments. Several works have presented many algorithms' optimizations. New computing technologies (SIMD coprocessors, multi-cores) can greatly accelerate the system processing but require rethinking the algorithm implementation. This paper presents an efficient implementation of the EKF-SLAM algorithm on a multicore architecture. The algorithm-architecture adequacy aims to optimize the implementation of the SLAM algorithm on a low-cost architecture (Dual-core and Dual SIMD coprocessor). Experiments were conducted with an instrumented platform. Results aim to demonstrate that an optimized implementation of the algorithm, resulting from an evaluation methodology, can help to design embedded systems implementing low-cost multicore architecture operating under real time constraints.

The vehicle's localization is classically achieved by Bayesian methods like Extended Kalman Filtering. Such methods provide an estimated position with its associated uncertainty. Bounded-error approaches (Bounded-Error State Estimation and Constraints Propagation) use interval analysis and work in a different way as they provide a possible set of positions. An advantage of bounded-error approaches over Bayesian methods is that their results are guaranteed (whereas the results of Bayesian methods are probabilistically defined). This paper compares both Bounded-Error State Estimation and Constraints Propagation using the same experimental data. The results obtained aim to rank these approaches in terms of computing time, consistency and imprecision.

The vehicle's localization is classically achieved by Bayesian methods like Extended Kaiman Filtering. Such a method provides an estimated position with its associated uncertainty. Bounded-error approaches using interval analysis work in a different way as they provide a possible set of positions. An advantage of such approaches is that the results are guaranteed and are not probabilistically defined. This paper focuses on constraints propagation techniques using static and dynamic fusion. Static fusion uses data redundancy to enhance proprioceptive data. Then dynamic fusion uses GPS in order to reduce the size of the localization box. The approach has been validated with a real outdoor vehicle.

Localization is a part of many automotive applications where safety is of crucial importance. We think that the best way to guarantee the safety in these applications is to guarantee the results of their embedded localization algorithms. Unfortunately localization of vehicles is mostly solved by Bayesian methods which (due to their structure) can only guarantee their results in a probabilistic way. Interval analysis allows an alternative approach with bounded-error state estimation. Such an approach provides a bounded set of configurations that is guaranteed to surround the actual vehicle configuration. We have validated the bounded-error state estimation with an outdoor vehicle equipped with odometers, a GPS receiver and a gyro. With the experimental results we compare the bounded-error state estimation with the particle filter localization in terms of consistency and computation time.