This thesis deals with the design and implementation of a simulator of PicoBlaze microcontroller. The aim of this thesis is to create a graphical simulator of this microcontroller in Eclipse as an extension of the existing integrated development environment VLAM IDE. The thesis describes in detail the simulator uCsim which was chosen for implementation of PicoBlaze simulator core and introduces its improvements for a better support of automatized testing. The thesis also presents a description of desing and implementation of the graphical simulator in Eclipse which uses the created simulator core and discusses possible improvements of the implemented core and graphical simulator.

This master's thesis is focused on GPU accelerated calculations on NVidia graphics card. CUDA technology is used and converted to implementation on a .NET platform. The problem is solved as a compiler from C# programing language to NVidia CUDA language with expression atrributes of C# language that preserves the same semantics of actions. Application is implemented in C# programing language and uses NRefactory, the open-source library.

Les architectures modernes avec des processeurs multicœurs, ainsi que les langages de programmation modernes, ont des mémoires faiblement consistantes. Leur comportement est formalisé par le modèle mémoire de l'architecture ou du langage de programmation ; il définit précisément quelle valeur peut être lue par chaque lecture dans la mémoire partagée. Ce n'est pas toujours celle écrite par la dernière écriture dans la même variable, à cause d'optimisation dans les processeurs, telle que l'exécution spéculative d'instructions, des effets complexes des caches, et des optimisations dans les compilateurs. Dans cette thèse, nous nous concentrons sur le modèle mémoire C11 qui est défini par l'édition 2011 du standard C. Nos contributions suivent trois axes. Tout d'abord, nous avons regardé la théorie autour du modèle C11, étudiant de façon formelle quelles optimisations il autorise les compilateurs à faire. Nous montrons que de nombreuses optimisations courantes sont permises, mais, surprenamment, d'autres, importantes, sont interdites. Dans un second temps, nous avons développé une méthode à base de tests aléatoires pour détecter quand des compilateurs largement utilisés tels que GCC et Clang réalisent des optimisations invalides dans le modèle mémoire C11. Nous avons trouvés plusieurs bugs dans GCC, qui furent tous rapidement fixés. Nous avons aussi implémenté une nouvelle passez d'optimisation dans LLVM, qui recherchent des instructions des instructions spéciales qui limitent les optimisations faites par le processeur - appelées instructions barrières - et élimine celles qui ne sont pas utiles. Finalement, nous avons développé un ordonnanceur en mode utilisateur pour des threads légers communicants via des canaux premier entré-premier sorti à un seul producteur et un seul consommateur. Ce modèle de programmation est connu sous le nom de réseau de Kahn, et nous montrons comment l'implémenter efficacement, via les primitives désynchronisation de C11. Ceci démontre qu'en dépit de ses problèmes, C11 peut être utilisé en pratique. / Modern multiprocessors architectures and programming languages exhibit weakly consistent memories. Their behaviour is formalised by the memory model of the architecture or programming language; it precisely defines which write operation can be returned by each shared memory read. This is not always the latest store to the same variable, because of optimisations in the processors such as speculative execution of instructions, the complex effects of caches, and optimisations in the compilers. In this thesis we focus on the C11 memory model that is defined by the 2011 edition of the C standard. Our contributions are threefold. First, we focused on the theory surrounding the C11 model, formally studying which compiler optimisations it enables. We show that many common compiler optimisations are allowed, but, surprisingly, some important ones are forbidden. Secondly, building on our results, we developed a random testing methodology for detecting when mainstream compilers such as GCC or Clang perform an incorrect optimisation with respect to the memory model. We found several bugs in GCC, all promptly fixed. We also implemented a novel optimisation pass in LLVM, that looks for special instructions that restrict processor optimisations - called fence instructions - and eliminates the redundant ones. Finally, we developed a user-level scheduler for lightweight threads communicating through first-in first-out single-producer single-consumer queues. This programming model is known as Kahn process networks, and we show how to efficiently implement it, using C11 synchronisation primitives. This shows that despite its flaws, C11 can be usable in practice.

Ziel der Arbeit ist die Erweiterung des Software-Werkzeuges ¨SAPCDEM¨ um eine Skriptsprache. Dieses Werkzeug wurde in der Abteilung ¨SAP R/3 Software Factory¨ der SAP AG entwickelt und dient der Verwaltung und Qualitaetssicherung der SAP R/3 CD's. Im Rahmen dieser Arbeit wird das Werkzeug hinsichtlich seines Aufbaus und seiner Arbeitsweise analysiert. Es werden die genauen Anforderungen an die Skriptsprache ermittelt und Loesungsansaetze diskutiert, diese in das vorhandene System zu integrieren. Ein Interpreter wird entworfen, der die Anweisungen der Sprache in entsprechende Aktionen des Werkzeuges umsetzt.

The rank revealing QR decomposition is a special form of the well known QR decomposition of a matrix. It uses specialized pivoting strategies and allows for an easy and efficient numerical rank decision for arbitrary matrices. It is especially valuable when column compression of rectangular matrices needs to be performed. Here we provide documentation and compilation instructions for a MATLAB MEX implementation of the RRQR allowing the easy usage of this decomposition inside the MATLAB environment.

The aim of this master's thesis is to design and implement JavaScript interpreter which is designed for purposes of avoiding obfuscation code of various types of computer viruses. This master's thesis also comprises a detailed view into the inner mechanism of the ECMAScript standard.

We often want a compiler to generate executable code that runs as fast as possible. One consideration toward this goal is to keep values in fast registers to limit the number of slower memory accesses that occur. When there are not enough physical registers available for use, values are ``spilled'' to the runtime stack. The need for spills is discovered during register allocation wherein values in use are mapped to physical registers. One factor in the efficacy of register allocation is the number of values in use at one time (register collisions). Register collision is affected by compiler optimizations that take place before register allocation. Though the main purpose of compiler optimizations is to make the overall code better and faster, some optimizations can actually increase register collisions. This may force the register allocation process to spill. This thesis studies the effects of different compiler optimizations on register collisions.

Automatic parallelization is the conversion of sequential code into multi-threaded code with little or no supervision. An ideal implementation of automatic parallelization would allow programmers to fully utilize available hardware resources to deliver optimal performance when writing code. Automatic parallelization has been studied for a long time, with one result being that modern compilers support vectorization without any input. In the study, contemporary parallelizing compilers are studied in order to determine whether or not they can easily be used in modern software development, and how code generated by them compares to manually parallelized code. Five compilers, ICC, Cetus, autoPar, PLUTO, and TC Optimizing Compiler are included in the study. Benchmarks are used to measure speedup of parallelized code, these benchmarks are executed on three different sets of hardware. The NAS Parallel Benchmarks (NPB) suite is used for ICC, Cetus, and autoPar, and PolyBench for the previously mentioned compilers in addition to PLUTO and TC Optimizing Compiler. Results show that parallelizing compilers outperform serial code in most cases, with certain coding styles hindering the capability of them to parallelize code. In the NPB suite, manually parallelized code is outperformed by Cetus and ICC for one benchmark. In the PolyBench suite, PLUTO outperforms the other compilers to a great extent, producing code not only optimized for parallel execution, but also for vectorization. Limitations in code generated by Cetus and autoPar prevent them from being used in legacy projects, while PLUTO and TC do not offer fully automated parallelization. ICC was found to offer the most complete automatic parallelization solution, although offered speedups were not as great as ones offered by other tools. / Automatisk parallellisering innebär konvertering av sekventiell kod till multitrådad kod med liten eller ingen tillsyn. En idealisk implementering av automatisk parallellisering skulle låta programmerare utnyttja tillgänglig hårdvara till fullo för att uppnå optimal prestanda när de skriver kod. Automatisk parallellisering har varit ett forskningsområde under en längre tid, och har resulterat i att moderna kompilatorer stöder vektorisering utan någon insats från programmerarens sida. I denna studie studeras samtida parallelliserande kompilatorer för att avgöra huruvida de lätt kan integreras i modern mjukvaruutveckling, samt hur kod som dessa kompilatorer genererar skiljer sig från manuellt parallelliserad kod. Fem kompilatorer, ICC, Cetus, autoPar, PLUTO, och TC Optimizing Compiler inkluderas i studien. Benchmarks används för att mäta speedup av paralleliserad kod. Dessa benchmarks exekveras på tre skiljda hårdvaruuppsättningar. NAS Parallel Benchmarks (NPB) används som benchmark för ICC, Cetus, och autoPar, och PolyBench för samtliga kompilatorer i studien. Resultat visar att parallelliserande kompilatorer genererar kod som presterar bättre än sekventiell kod i de flesta fallen, samt att vissa kodstilar begränsar deras möjlighet att parallellisera kod. I NPB så presterar kod parallelliserad av Cetus och ICC bättre än manuellt parallelliserad kod för en benchmark. I PolyBench så presterar PLUTO mycket bättre än de andra kompilatorerna och producerar kod som inte endast är optimerad för parallell exekvering, utan också för vektorisering. Begränsningar i kod genererad av Cetus och autoPar förhindrar användningen av dessa redskap i etablerade projekt, medan PLUTO och TC inte är kapabla till fullt automatisk parallellisering. Det framkom att ICC erbjuder den mest kompletta lösningen för automatisk parallellisering, men möjliga speedups var ej på samma nivå som för de andra kompilatorerna.

Immutable data and persistent data structures are seeing more and more use. Many common programming errors can be solved by simply using immutable data, and in concurrent and parallel programming, they remove the need for data synchronization. There are many benefits of immutable data, but few modern languages provide a way to declare or control immutability. By analyzing a class, it is possible to know whether creating an object of that specific class will make an immutable object. This means that for final classes, which can't be extended, immutability can be inferred from the type. The same is not true for non-final classes. A mutable subclass can be made without recompiling the original, immutable superclass, making it possible to make mutable objects of the previously immutable class. This makes all non-final classes potentially mutable, ruling out many interesting class hierarchies. This thesis explores how the use of such unwanted class extensions could be detected. The solution introduces \emph{phantom classes}, synthetic final classes that are used in place of the original classes. These classes are essentially empty class extensions, behaving exactly the same as the original classes, but since they are final, can not be extended. An object can be verified by downcasting. If the cast fails, the object have been created in foreign code.A proof-of-concept is implemented as a fork of Dotty, what will become version 3 of the Scala compiler. The implementation is called Mållgan.Mållgan is able to compile real code, and produces executable JVM bytecode.Tests show that the code compiled with Mållgan can still be used normally by code compiled with regular Dotty, indicating that the solution is transparent to any code not aware of it. Overall the study shows that the solution is feasible, but a formal proof would be needed to provide definite proof for the correctness. / Omuterbar data och beständiga datastrukturer används mer och mer. Många vanliga programmeringsfel kan undvikas genom att använda omuterbar data, och i parallell och flertrådig programmering slipper man datasynkronisering. Det finns många fördelar med omuterbar data, men få moderna programmeringsspråk stödjer ett sätt att deklarera eller kontrollera omuterbarhet. Genom att analysera en klass är det möjligt att ta reda på om ett objekt som skapats från klassen är omuterbar. För klasser som inte går att ärva går det alltså att härleda om ett objekt är omuterbart eller inte från typen. För klasser som går att ärva finns inga garantier för att subklasserna är omuterbara, och subklasser kan skapas utan att orginalklassen måste kompileras om. Det här gör att alla klasser som går att ärva är potentiellt muterbara, vilket omöjliggör många intressanta klasshierarkier. Den här uppsatsen utforskar hur sådana oönskade subklasser kan upptäckas. Lösningen heter \emph{fantomklasser} (phantom classes), syntetiska klasser som inte går att ärva. Dessa är i grund och botten tomma subklasser som beter sig exakt likadant som orginalklasserna. Ett objekt kan verifieras genom att verifiera typen. Om de inte kan göras till fantomklassen måste de ha gjorts av främmande kod. Som proof-of-concept implementerades lösningen som en fork av Dotty, det som kommer att bli version 3 av Scala-kompilatorn. Implementationen heter Mållgan. Mållgan klarar att kompilera verklig kod och producerar exekverbar JVM bytekod. Tester visar att kod kompilerad med Mållgan fortfarande kan användas som vanligt med vanlig Dotty. Det här indikerar att lösningen är transparent för kod som inte är medveten om implementationen. Studien visar att lösningen är genomförbar, men ett mer formellt bevis krävs för att visa att lösningen är korrekt.

This thesis presents a tool for SPEcification based teSTing (SPEST). SPEST is designed to use well known practices for automated black-box testing to reduce the burden of testing on developers. The tool uses a simple formal specification language to generate highly-readable unit tests that embody best practices for thorough software testing. Because the specification language used to generate the assertions about the code can be compiled, it can also be used to ensure that documentation describing the code is maintained during development and refactoring. The utility and effectiveness of SPEST were validated through several exper- iments conducted with students in undergraduate software engineering classes. The first experiment compared the understandability and efficiency of SPEST generated tests against student written tests based on the Java Modeling Lan- guage (JML)[25] specifications. JML is a widely used language for behavior program specification. A second experiment evaluated readability through a sur- vey comparing SPEST generated tests against tests written by well established software developers. The results from the experiments showed that SPEST’s specification language is at least understandable as JML, SPEST’s specification language is more readable than JML, and strongly suggest that SPEST is capable of reducing the effort required to produce effective tests.