This master's thesis deals with the support for compilation and execution of programs written using OpenCL framework on embedded systems. OpenCL is a system for programming heterogeneous systems comprising processors, graphic accelerators and other computing devices. But it also finds usage on systems composed of just one computing unit, where it allows to write parallel programs (task and data parallelism) and work with hierarchical system of memories. In this thesis, various available open source OpenCL implementations are compared and one selected is then integrated into LLVM compiler infrastructure. This compiler is generated as a part of toolchain provided by application specific instruction set architecture processor developement environment called Codasip Studio. Designed and implemented are also optimizations for architectures with SIMD instructions and VLIW architectures. The result is tested and demonstrated on a set of testing applications.

Fuzzing, the method of generating inputs to run on a target program while monitoring its execution, is a widely adopted and pragmatic methodology for bug hunting as a means of software hardening. Technical improvements in throughput have shown to be critical to increasing the rate at which new bugs can be discovered time and time again. Persistent fuzzing, which keeps the fuzz target alive via looping, provides increased throughput at the cost for manual development of harnesses to account for invalid states and coverage of the programs code base, while relying on forking to reset the state accrued by looping over the same piece of code multiple times. Stale state can lead to wasted fuzzing efforts as certain areas of code may be conditionally ignored due to a stale global. I propose Closure, a toolset which enables programs to run at persistent speeds while avoiding the downsides of stale state and other bottlenecks associated with persistent fuzzing. / Master of Science / The process of program testing to find bugs is becoming increasingly automated. A current method called "Fuzzing", is a widely adopted means for finding bugs and is required in the life cycle of program development by major companies and the US Government. I look at current improvements in fuzzing, and expand the use case of the cutting edge method called persistent fuzzing to a wider array of applications with my tool Closure. With Closure, fuzzing practitioners can experience faster fuzzing performance with less manual effort.

Compiler optimizations in the context of traditional program execution is a well-studied research area, and modern compilers typically offer a suite of optimization options. This thesis reports the first study (to our knowledge) on how standard compiler optimizations influence symbolic execution. We study 33 optimization flags of the LLVM compiler infrastructure, which are used by the KLEE symbolic execution engine. Specifically, we study (1) how different optimizations influence the performance of KLEE for Unix Coreutils, (2) how the influence varies across two different program classes, and (3) how the influence varies across three different back-end constraint solvers. Some of our findings surprised us. For example, KLEE's setting for applying the 33 optimizations in a pre-defined order provides sub-optimal performance for a majority of the Coreutils when using the basic depth-first search; moreover, in our experimental setup, applying no optimization performs better for many of the Coreutils. / text

This thesis describes the development of a compiler for OpenGLES 2.0 programs for a novel GPU. This work is a part of a larger project to develop a low-power GPU for embedded systems. Our compiler has been developed in the LLVM compiler infrastructure. The present thesis focuses on three areas of the compiler: 1) making corrections and improvements to an existing graphics shading language parser, 2) augmenting LLVM¡¦s bit-code format to support the new information from the shading language, and 3) modifying LLVM¡¦s backend to support this augmented bit-code. Much of this work is related to supporting the matrix and vector primitive data types found in OpenGL¡¦s GLSL shading language. In conjunction with several other theses, as listed in the text, this work achieves a working basic compiler for GLSL code on our new GPU. Continuing work by future researchers is necessary to make the compiler more robust and optimized.

This master's thesis deals with the integrations of C++ programming language and its standard C++11 into the compiler for embedded systems. This compiler is based on LLVM project and it is generated from Codasip Studio. Codasip Studio is tool for design of the aplication specific processor cores, it is also allows generate compiler, which is based on the description of semantics section in processor's instruction set for any target processor architecture. C++ is programming language based on the C, which is extended by object oriented design and many other features. C++ language allows writing of very effective code on high level of abstraction. Funcionality of implementation is tested on testsuite in last phase of master's thesis.

To ensure the correctness of real time systems, it is important to determine the execution time of tasks. The worst case execution time of each task needs to be found in order to determine if the system is schedulable. This thesis aims at bounding the execution time of programs analyzed by KLEE, a symbolic execution engine. This is done by estimating the cycles required on the Cortex-M4 processor. A custom fork of KLEE has been created which outputs additional information about the program under analysis. This information is used by a tool written in Rust which reconstructs the corresponding control flow in optimized assembly code. KLEE analyzes an intermediate representation language, LLVM IR. This representation is used in the compilation process of many programming languages. One of these languages is Rust which has been the primary focus of the tool. Testing has been done on applications written with the RTIC framework. The measured cycles of these applications has been correctly bounded for all test cases.

No description available.

No description available.

This thesis describes the design and implementation of a prototype LLVM compiler backend, x86-64p, that compiles code written for a DSP architecture, FADER, into executables for the x86-64 architecture. The prototype takes LLVM IR generated for the FADER architecture and compiles x86-64 executables that emulate the properties of the DSP architecture, e.g. the multiple address spaces, the big-endianness and the support for fixed-point arithmetics. The backend is compared to a previous solution, C-Emu, that converts the DSP code to normal C code that is compiled using a normal x86-64 compiler. The two solutions are compared in terms of their correctness, debuggability and performance. The created prototype handles code containing low-level architectural assumptions better than C-Emu. However, the added emulation reduces the debuggability and performance of the generated executables. We have measured a runtime overhead of up to a factor of two compared to C-Emu. We also present some possible solutions for these issues.

Background. Performance monitoring of C/C++ programs has often been a tedious and straining process, where insufficient and complex tools/APIs are required. Performance monitoring tools and APIs tend to focus on ease of use or flexibility, but rarely both. Hence, a tool that combines ease of use and flexibility while enhancing abstraction, would greatly simplify the monitoring of C/C++ programs and seamlessly integrate them into pre-existing projects. Objectives. This study aims to extend the developed EDPM prototype used for the manual performance monitoring of C/C++ programs. The extension will comprise the dynamic nesting feature which will be the primary focus of this thesis study. Method. In this thesis study, experiments that evaluate the extended EDPM version will be conducted. These experiments will be conducted using a homogeneous testing environment using an independent benchmark created for this study: strncpy, and a C/C++ benchmark: rodinia. The experiments will consist of measuring the execution benefits, overheads, and precision of the initial EDPM version, extended EDPM version, and the raw Performance API(PAPI) which will be used manually. For this purpose, four sets of tests will be orchestrated; iterative and recursive test programs for the strncpy benchmark; binary search tree and b+tree test programs for the rodinia benchmark. Additionally, each set is divided into two scenarios: nested and alternate structures. The iterative tests will be used to evaluate all of the three aformentioned subjects, and the recursive tests will evaluate the extended EDPM version and the PAPI API. The binary search tree and b+tree tests will further evaluate the initial and extended EDPM versions in CPU and memory-intensive environments. Furthermore, the test sets will each adopt different configurations, depending on the specific test. Additionally, the reason why the initial EDPM version won’t be evaluated using the recursive tests is because it doesn’t support the dynamic nesting feature. Results. The results show that the extended EDPM version had an improved execution time, for each respective configuration, for each benchmark. The results also show that the PAPI API outperforms both of the EDPM versions significantly but with the compromise of sacrificing some precision. Conclusions. As of this thesis study, EDPM is a prototype in development, but now with the implemented dynamic nesting extension, EDPM will facilitate the implementation of further extensions, such as the multithreading monitoring, by primarily using the PAPI API as its core backend. Additionally, the extended EDPM version is slightly optimized compared to the initial EDPM version but significantly unoptimized when compared to the PAPI API, depending on how a program has been annotated. / Bakgrund. Prestandamätning av C/C++ program har ofta varit en påfrestande process, där otillräckliga och komplexa verktyg samt API:er är nödvändiga. Verktyg och API:er ämnade för prestandamätning fokuserar vanligen på en sida av spektrumet; användarvändlighet eller flexibilitet, men oftast inte båda. Därför, ett verktyg som slår ihop användarvändlighet och flexibilitet, som samtidigt också höjer abstraktionsnivån hade underlättat både processen av prestandamätning men även integrationen av ett sådant verktyg i existerande och framtida projekt. Syfte. Denna studie fokuserar på att utöka EDPM prototypen som används för manuell prestandamätning av C/C++ program. Utökningen kommer att omfatta implementationen av funktionaliteten dynamisk nestning. Metod. I denna studie kommer experiment som utvärderar den utökade EDPM versionen att utföras. Experimenten kommer att använda en homogen testmiljö och två teststandarder, där en teststandard kommer att skapas: strncpy; och en C/C++ teststandard att återanvändas: rodinia. Experimenten kommer att bestå av att mäta fördelarna, överhuvudet för exekveringstiden samt precisionen för den initiala EDPM versionen, utökade EDPM versionen och det råa/manuellt använda Performance API:et(PAPI). Experimentet kommer att omfatta fyra distinkta par av tester; de iterativa och rekursiva testerna för strncpy teststandarden; de binary search tree och b+tree testerna för rodinia teststandarden. Varje par är uppdelat i två scenario: nästade och alternerande strukturer. De iterativa testerna kommer att användas för att utvärdera alla tidigare nämnda testsubjekt, medan de rekursiva testerna kommer att utvärdera den utökade EDPM versionen och PAPI API:et. De binary search tree och b+tree testerna kommer att användas för att ytterligare utvärdera den initiala och utökade EDPM versionerna i en CPU and minnes-intensiv programmiljö. Paren av tester kommer dessutom att använda sig av olika konfigurationer, beroende på det specifika testet som utförs. Anledningen till varför den initiala EDPM versionen inte kommer att utvärderas med de rekursiva testerna är eftersom versionen inte stödjer funktionaliteten dynamisk nesting. Resultat. Resultaten visar att den utökade EDPM versionen presterar både snarlikt och bättre i jämförelse mot den initiala EDPM versionen, för respektive test från samt konfiguration. Resultaten visar även att PAPI API:et överträffar båda EDPM versionerna genom att offra någon andel precision. Slutsatser. Under tiden av skrivandet av detta examensarbete är EDPM endast en prototyp under utveckling, men genom additionen av funktionaliteten dynamisk nesting, kommer implementation av framtida utökningar att underlättas, t.ex. mätning av multitrådade program genom att primärt använda PAPI API:et. Utöver den generella utökningen har EDPM blivit något mer optimerad jämförelsevis med den initiala EDPM versionen men avsevärt sämre jämförelsevis med PAPI API:et, detta beroende på hur ett program blivit annoterat.