• Refine Query
  • Source
  • Publication year
  • to
  • Language
  • 27
  • 19
  • 3
  • 2
  • 1
  • 1
  • Tagged with
  • 58
  • 18
  • 15
  • 12
  • 11
  • 10
  • 9
  • 8
  • 8
  • 8
  • 7
  • 7
  • 7
  • 6
  • 6
  • About
  • The Global ETD Search service is a free service for researchers to find electronic theses and dissertations. This service is provided by the Networked Digital Library of Theses and Dissertations.
    Our metadata is collected from universities around the world. If you manage a university/consortium/country archive and want to be added, details can be found on the NDLTD website.
1

Překlad OpenCL aplikací pro vestavěné systémy / Compilation of OpenCL Applications for Embedded Systems

Šnobl, Pavel January 2016 (has links)
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.
2

Closure: Transforming Source Code for Faster Fuzzing

Paterson, Ian G. 27 May 2022 (has links)
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.
3

An empirical study of the influence of compiler optimizations on symbolic execution

Dong, Shiyu 18 September 2014 (has links)
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
4

Compiler Support for Vector Processing on OpenGL ES 2.0 Programs

Huang, Kuo-An 02 September 2010 (has links)
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.
5

Překlad C++ aplikací pro vestavěná zařízení / Compilation of C++ Applications for Embedded Devices

Nosterský, Milan January 2019 (has links)
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.
6

Scalable Analysis of Large Dynamic Dependence Graphs

Singh, Shashank 01 September 2015 (has links)
No description available.
7

Compile-Time Characterization of Recurrent Patterns in Irregular Computations

Singri, Arjun Jagadeesh 03 September 2010 (has links)
No description available.
8

Recompiling DSP applications to x86 using LLVM IR

Stenberg, David January 2014 (has links)
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.
9

Software Based GPU Framework

Miretsky, Evgeny 05 December 2013 (has links)
A software based GPU design, where most of the 3D pipeline is executed in software on shaders, with minimal support from custom hardware blocks, provides three benefits, it: (1) simplifies the GPU design, (2) turns 3D graphics into a general purpose application, and (3) opens the door for applying compiler optimization to the whole 3D pipeline. In this thesis we design a framework and a full software stack to support further research in the field. LLVM IR is used as a flexible shader IR, and all fixed-function hardware blocks are translated into it. A sort-middle, tile-based, architecture is used for the 3D pipeline and trace-file based methodology is applied to make the system more modular. Further, we implement a GPU model and use it to perform an architectural exploration of the proposed software based GPU system design space.
10

Software Based GPU Framework

Miretsky, Evgeny 05 December 2013 (has links)
A software based GPU design, where most of the 3D pipeline is executed in software on shaders, with minimal support from custom hardware blocks, provides three benefits, it: (1) simplifies the GPU design, (2) turns 3D graphics into a general purpose application, and (3) opens the door for applying compiler optimization to the whole 3D pipeline. In this thesis we design a framework and a full software stack to support further research in the field. LLVM IR is used as a flexible shader IR, and all fixed-function hardware blocks are translated into it. A sort-middle, tile-based, architecture is used for the 3D pipeline and trace-file based methodology is applied to make the system more modular. Further, we implement a GPU model and use it to perform an architectural exploration of the proposed software based GPU system design space.

Page generated in 0.0598 seconds