SAGE (Statement Analysis Grouping Evaluation) system is a statement-based parallelizing compiler designed for PIM (Processor-in-Memory) architectures. By extracting the potential parallelism and utilizing the capabilities of PIM architectures, this system can achieve better performance of the applications. It analyzes the source codes, transforms the codes, makes good executing schedule and generates the codes which can execute on PIM architectures. This thesis focuses on the implementation of the code generator in the SAGE system. The code generator can transforms the original source codes into subroutines according to the corresponding HBG (Hyper Block Graph) and execution schedule which is determined by the other modules of SAGE system. It generates subroutines, inserts necessary arguments, determines the positions of caller and callee and generates the interface program for executing on PIM simulator. The generated codes after our code generator are also discussed.

A component is built to be reused and reusability has significant impact on component generality and flexibility requirement. A component model plays a critical role in reusability of software component and defines a set of standards for component implementation, evolution, composition, deployment and standardization of the run-time environment for execution of component. In component based development (CBD), standardization of the runtime environment includes specification of component’s interfaces – general and domain specific run-time services. For rapid development of component based system for distributed information systems, COM+ and .NET technologies introduced the idea of Software Component Services that are achieved by proxy objects which intercept message calls between components to provide service like transaction handling, security management, etc. An embedded real-time system (ERTS) designed for a specific purpose in which software tasks have hard real-time constraints to execute and it interact directly with its environment via buses, sensors and other devices. In an embedded real time system, it is great importance to ensure that all tasks of the software system should respond within the time limits. Component based development process have vital role in development of embedded real time system and recently software component models applied in the embedded real-time systems (ERTS) and introduced software component services (SCS) for ERTS. The purpose of this Master thesis is to investigate how to make tool that targets smart device projects in Microsoft Visual Studio and generates proxy objects that can be compiled with Microsoft Visual Studio.NET. The tool generates a complete set of files for a Microsoft Visual Studio smart device project within solution, including both source code and configuration files according to a specific version of Visual Studio by invoking Visual Studio’s automation object model. The tool also generates code for simple logging services for the .NET component running on top of the .NET Compact framework.

Eine wichtige Aufgabe bei der Softwareentwicklung ist das Auffinden von Fehlern und das Verstehen ihrer Ursachen. Zur Unterstützung dieser Aufgabe gibt es zahlreiche De-bugger. Bei der Nutzung von Softwaregeneratoren benötigt man zum Debuggen spezielle Informationen. In dieser Arbeit werden Anforderungen an einen Debugger für Software-generatoren definiert. Dazu werden zunächst strukturell ähnliche Softwaregeneratoren auf ihre Debugger untersucht und grundsätzliche Debuggertypen identifiziert. Aus diesen werden 15 Anforderungen formuliert, die der hier beispielhaft betrachtete Softwaregener-ator erfüllen soll. Anschließend erfolgen eine Verallgemeinerung der Ergebnisse und eine kurze Diskussion der Umsetzung auf der Plattform JetBrains MPS.

<p>A new, template-based code generator has been implemented for the OpenModelica compiler. All data needed for target code generation has been collected in a new data structure that is then sent to templates which generate target code based on that data. This simplifies the implementation of the code generator and also makes it possible to write a different set of templates to generate target code in a different language.</p><p>The new, template-based code generator currently only supports generation of target code for simulating Modelica models. In that scenario it translates models roughly at the same speed as the old code generator.</p>

A new, template-based code generator has been implemented for the OpenModelica compiler. All data needed for target code generation has been collected in a new data structure that is then sent to templates which generate target code based on that data. This simplifies the implementation of the code generator and also makes it possible to write a different set of templates to generate target code in a different language. The new, template-based code generator currently only supports generation of target code for simulating Modelica models. In that scenario it translates models roughly at the same speed as the old code generator.

The current OpenModelica Complier (OMC) translates Modelica models into executable Ccodethrough several stages. The Code Generator is the final stage of the compiler whichgenerates target C-code from the optimized sorted equations. Recently, the Code Generator inOMC has been rewritten using the OpenModelica text template language. This gives a moreconcise and easier to understand code generator. Modeling and simulation is becomingincreasingly used in several application areas. There is demand for the OpenModelicaComplier (OMC) to generate code in languages like C#, CSharp, XML, JAVA and so on. Inthis thesis work, we implement a Java code generator to translate the internal equation-basedmodels in OpenModelica and its extension MetaModelica into a Java code representation. Tocreate the Java code generator we used the OpenModelica text template language, also calledSusan. This work is an important step on the way to finalize a full version of a Java CodeGenerator for the OpenModelica Complier (OMC).

In today’s fast paced changing technology world, it is essential to adapt the new technologies and standards in order to stay compliant with the market. Software development is one of those key areas that have been growing highly fast and thus the need for staying up to date needs to be acknowledged by everyone in the area. The technology focused in this project is called ModelicaML[1] which is an integrated system modeling environment based on standardized languages such as UML[2] and Modelica[3]. Modelica Modeling Language (ModelicaML) is a graphical modeling language used for the description of time-continuous and time-discrete/event-based system dynamics. Currently, a ModelicaML code generator – that generates Modelica code from UML models – is implemented using the old Acceleo framework[4]. Within this thesis, the ModelicaML code generator was re-factored and implemented by using the latest Acceleo version 3.X[5]. The differences between the old and new Acceleo framework was also given an evaluation in the study in order to provide a hint of its future use for further improvements of the code generator.

Main objective of this thesis is to extend existing functionality of Integrated Development Environment (IDE) BlueJ with possibility of working with streams in an interactive mode. This new functionality helps to falicitate and improve teaching of programming within the First Architecture methodology. First part of this thesis deals with IDE BlueJ and discusses problematic software con-structions which don´t have sufficient support in interactive mode. Main focus is put on streams. Another part of this thesis suggests possible options for extension which should be integrated to the existing functionality. Following part focuses on analysis of the proposed changes and final part discusses implementation itself and describes author´s process of realization.

ITC/USA 2005 Conference Proceedings / The Forty-First Annual International Telemetering Conference and Technical Exhibition / October 24-27, 2005 / Riviera Hotel & Convention Center, Las Vegas, Nevada / The GPS receiver based on software radio technology is a kind of general purpose GPS signal processing platform which makes use of advanced design ideas and advanced design tools nowadays. We used FPGA device and lots of necessary peripherals such as DSP and PCI controller in our design to promote flexibility and practicability effectively. Various fast acquisition means and accurate tracking algorithms could be realized, improved and validated on this platform, besides basic GPS receiver function.

Programming has advanced a great deal since the appearance of the stored-program architecture. Through the successive generations of machine codes, assembly languages, high-level languages, and object-oriented languages, the drive has been toward program descriptions that express more meaning in a shorter space. This trend continues today with domain-specific languages. However, conventional languages rely on a textual formalism (commands, statements, lines of code) to capture the programmer's intent, which, regardless of its level of abstraction, imposes inevitable overheads. Before successful programming activities can take place, the syntax has to be mastered, names and keywords memorized, the library routines mastered, etc. Existing visual programming languages avoid some of these overheads, but do not release the programmer from the task of specifying the program logic, which consumes the main portion of programming time and also is the major source of difficult bugs. Our work aims to minimize the demands a formalism imposes on the programmer of geometric subroutines other than what is inherent in the problem itself. Our approach frees the programmer from syntactic constraints and generates logically correct programs automatically from program descriptions in the form of diagrams. To write a program, the programmer simply draws a few diagrams to depict the problem context and specifies all the necessary parameters through menu operations. Diagrams are succinct, easy to learn, and intuitive to use. They are much easier to modify than code, and they help the user visualize and analyze the problem, in addition to providing information to the computer. Furthermore, diagrams describe a situation rather than a task and thus are reusable for different tasks—in general, a single diagram can generate many programs. For these reasons, we have chosen diagrams as the main specification mechanism. In addition, we leverage the power of automatic inference to reason about diagrams and generic components—the building blocks of our programs—and discover the logic for assembling these components into correct programs. To facilitate inference, symbolic facts encode entities present in the diagrams, their spatial relationships, and the preconditions and effects of reusable components. We have developed a reference implementation and tested it on a number of real-world examples to demonstrate the feasibility and efficacy of our approach. / text