This thesis presents a two step automatic transformation of Field Artillery Mission Space Conceptual Models (ACMs) into High Level Architecture (HLA) Federation Architecture Models (FAMs) into executable distributed simulation code. The approach followed in the course of this thesis adheres to the Model-Driven Engineering (MDE) philosophy. Both ACMs and FAMs are formally defined conforming to their metamodels, ACMM and FAMM, respectively. ACMM is comprised of a behavioral component, based on Live Sequence Charts (LSCs), and a data component based on UML class diagrams. Using ACMM, the Adjustment Followed by Fire For Effect (AdjFFE) mission, which serves as the source model for the model transformation case study, is constructed. The ACM to FAM transformation, which is defined over metamodel-level graph patterns, is carried out with the Graph Rewriting and Transformation (GReAT) tool. Code generation from a FAM is accomplished by employing a model interpreter that produces Java/AspectJ code. The resulting code can then be executed on an HLA Run-Time Infrastructure (RTI). Bringing a fully fledged transformation approach to conceptual modeling is a distinguishing feature of this thesis. This thesis also aims to bring the chart notations to the attention of the mission space modeling community regarding the description of military tasks, particularly their communication aspect. With the experience gained, a set of guidelines for a domainindependent transformer from any metamodel-based conceptual model to FAM is offered.

Der Große Beleg dokumentiert die Entwicklung eines Java Code-Generators für Dresden OCL2 for Eclipse. Schwerpunkt der Arbeit liegt dabei auf der Abbildung der Object Constraint Language auf die Programmiersprache Java mit Hilfe von AspectJ.

The interest of drones in all forms has exploded in the recent years. The development of multirotor vehicles such as quadcopters and octocopters, has reached a point where they are cheap and versatile enough to start becoming a part of everyday life. It is clear to say that the future applications seem limitless. This thesis goes through the steps of development, modelling and control design of an octocopter system. The developed octocopter builds on a concept of using the mini computer Raspberry Pi together with the code generation functionality of Matlab/Simulink. The mathematical modelling of the octocopter includes the thrust and torques generated by the propellers, added with gyroscopic torque. These are combined with the aerodynamic effects caused by incoming air. The importance of modelling the later mentioned effects has increased with the demand of precise controlled extreme manoeuvres. A full state feedback based hybrid controller scheme is designed against a linearized model, which makes use of the motor dynamics. The controllers show good performance in simulations and are approved for flight tests, which are conducted on two separate occasions. The octocopter makes two successful flights, proving that the concept can be applied on multirotor vehicles. However, there is a miss-match between the mathematical model and the physical octocopter, leaving questions for future work.

Daugeliui įmonių ar organizacijų reikalingos informacinės sistemos, skirtos valdytį jų procesus duomenis. Darbe analizuojamos verslo procesų, transakcijų modeliavimo galimybės, technologijos, standartai: RUP, UML, XML (XMI), MERODE, R. Gusto, WAE, BPMN, MDA, Agile. Deliau analizuojamas verslo procesų modelis ir jo plėtinys BPMN. Pateikti pasiųlymai notacijos išplėtimui duomenų objektais, modelių ir elementų interpretacija modeliuojant o modelius panaudojant kodo generavime. Sudarytas ir ištestuotas pilnai funkcionuojančio ir dalykinę sritį atitinkančio kodo generavimo algoritmas. / In nowadays a lot of business companies and organizations are using information systems. This paper analyses business transactions, tools and technologies for transactions and process modelling of information and enterprise systems. Analyzed popular technologies like UML and its extensions, RUP, XMI, MDA. Familiarized with MERODE and Agile methods. More closely analyzed BPMN notation and its possibilities for code generation. BPMN notation augment with data objects for better code generation solutions. It also gives better understanding of data flows and influence of business process and transactions. Defined process and transactions modelling strategy which allows better code generations solution too. Made-up, practically materialized ant tested code generation algorithm.

Designing efficient code in practice for a given computation is a hard task. In this thesis, we tackle this issue in two different situations. The first part of the thesis introduces some algorithmic improvements in structured linear algebra. We first show how to extend an algorithm by Cardinal for inverting Cauchy-like matrices to the other common structures. This approach, which mainly relies on products of the type "structured matrix × matrix", leads to a theoretical speed-up of a factor up to 7 that we also observe in practice. Then, we extend some works on Toeplitz-like matrices and prove that, for any of the common structures, the product of an n×n structured matrix of displacement rank α by an n×α matrix can be computed in Õ(α^(ω-1)n). This leads to direct inversion algorithms in Õ(α^(ω-1)n) , that do not rely on a reduction to the Toeplitz-like case. The second part of the thesis deals with the implementation of arithmetic expressions. This topic raises several issues like finding the minimum number of operations, and maximizing the speed or the accuracy when using some finite-precision arithmetic. Making use of the inductive nature of arithmetic expressions enables the design of algorithms that help to answer such questions. We thus present a set of algorithms for generating evaluation schemes, counting them, and optimizing them according to one or several criteria. These algorithms are part of a library that we have developed and used, among other things, in order to decrease the running time of a code generator for a mathematical library, and to study optimality issues about the evaluation of a small degree polynomial with scalar coefficients at a matrix point.

Programinio kodo generavimo iš veiklos taisyklių modelių sritis iki šiol yra menkai ištirta ir tai neigiamai veikia veiklos taisyklių koncepcijos plėtrą. Nagrinėjama kodo generavimo iš grafinių IS (informacinių sistemų) reikalavimus atspindinčių modelių problema. Pristatomas modifikuotu Roso metodu grindžiamo veiklos taisyklių modeliavimo IS projektavimo stadijoje metodo tyrimas, siekiant sukurti adekvačią programinio kodo generavimo iš taisyklių diagramų metodiką. / One of the reasons for a relatively slow growth of the business rules approach could be the lack of developments in the field of program code generation from the business rules models. During this work methods for code generation from IS requirements models are analysed. The focus is placed on a modified Ross method based rules modelling method aiming to create an adequate code generation methodology.

The performance of a program can sometimes greatly improve if it was known in advance the features of the input the program is supposed to process, the actual operating parameters it is supposed to work with, or the specific environment it is to run on. However, this information is typically not available until too late in the program’s operation to take advantage of it. This is especially true for simulation algorithms, which are sensitive to this late-arriving information, and whose role in the solution of decision-making, inference and valuation problems is crucial. To overcome this limitation we need to provide the flexibility for a program to adapt its behaviour to late-arriving information once it becomes available. In this thesis, I study three adaptation mechanisms: run-time code generation, model-specific (quasi) Monte Carlo sampling and dynamic computation offloading, and evaluate their benefits on Monte Carlo algorithms. First, run-time code generation is studied in the context of Monte Carlo algorithms for time-series filtering in the form of the Input-Adaptive Kalman filter, a dynamically generated state estimator for non-linear, non-Gaussian dynamic systems. The second adaptation mechanism consists of the application of the functional-ANOVA decomposition to generate model-specific QMC-samplers which can then be used to improve Monte Carlo-based integration. The third adaptive mechanism treated here, dynamic computation offloading, is applied to wireless communication management, where network conditions are assessed via option valuation techniques to determine whether a program should offload computations or carry them out locally in order to achieve higher run-time (and correspondingly battery-usage) efficiency. This ability makes the program well suited for operation in mobile environments. At their core, all these applications carry out or make use of (quasi) Monte Carlo simulations on dynamic Bayesian networks (DBNs). The DBN formalism and its associated simulation-based algorithms are of great value in the solution to problems with a large uncertainty component. This characteristic makes adaptation techniques like those studied here likely to gain relevance in a world where computers are endowed with perception capabilities and are expected to deal with an ever-increasing stream of sensor and time-series data.

In order to use components that are developed for a domain, domain knowledge is required. If the default relations in a domain are offered by a framework, this can be a starting point for the application engineer as an important kind of domain knowledge. A generic design for creating and saving a domain is implemented in this thesis. This approach starts with creating a domain from components and relations among these components. The relations and components are saved once and used several times. In addition, this generic design helps for code generation by using components. A framework for this design is implemented and applied for GIS domain. A basic code generation approach is also implemented in this framework for demonstration purposes. This framework can be used by domain engineers in order to create a domain and by application engineers to develop custom applications. It has the ability to offer default relations and helps creating new relations between components. Parameters and sequence of function calls can be defined by using a GUI. All the relations including default and userdefined ones can be used for code generation. COSECASE, which offers a tool for component-oriented design is extended with domain operations such as creating domain, saving domain, loading domain, and generating domain code. As the starting point, domain analysis for GIS domain is completed to define the domain. Then the components that have been implemented for GIS domain and relations between these components are saved within the framework. Moreover, some basic applications are generated by using this framework in the GIS domain. Also a sample domain is created to prove that our approach can be applied to any domain. The relations in this sample domain are saved in the framework and same basic applications are generated.

Multi-stage programming is a valuable technique for improving the performance of computer programs through run-time optimization. Current implementations of multi-stage programming do not support run-time type introspection, which is a significant feature of modern object-oriented platforms such as Java and C#. This is unfortunate because many programs that use type introspection in these languages could be improved with multi-staging programming. The aim of this research is to investigate the interaction between multi-stage programming and object-oriented type introspection. This is done by the invention of a new programming language that is a multi-stage extension to C#. The language is capable of expressing traditional multi-stage programs as well as a new style of multi-stage programs that incorporate type introspection, most notably polytypic algorithms such as object serialization. A compiler for the language is implemented and freely available. The language is significant because it is the first object-oriented, multi-stage language; the first attempt to combine type introspection with multi-stage programming; and the first exploration of polytypic programming in a multi-stage context.

Processadores embarcados utilizam eficientemente o paralelismo a nível de instrução para atender as necessidades de desempenho e energia em aplicações atuais. Embora a melhoria de performance seja um dos principais objetivos em processadores em geral, ela pode levar a um impacto negativo no consumo de energia, uma restrição crítica para sistemas atuais. Nesta dissertação, apresentamos o SoMMA, uma arquitetura de memória gerenciada por software para processadores embarcados capaz de reduz consumo de energia e energy-delay product (EDP), enquanto ainda aumenta a banda de memória. A solução combina o uso de memórias gerenciadas por software com a cache de dados, de modo a reduzir o consumo de energia e EDP do sistema. SoMMA também melhora a performance do sistema, pois os acessos à memória podem ser realizados em paralelo, sem custo em portas de memória extra na cache de dados. Transformações de código do compilador auxiliam o programador a utilizar a arquitetura proposta. Resultados experimentais mostram que SoMMA é mais eficiente em termos de energia e desempenho tanto a nível de processador quanto a nível do sistema completo. A técnica apresenta speedups de 1.118x e 1.121x, consumindo 11% e 12.8% menos energia quando comparando processadores que utilizam e não utilizam SoMMA. Há ainda redução de até 41.5% em EDP do sistema, sempre mantendo a área dos processadores equivalentes. Por fim, SoMMA também reduz o número de cache misses quando comparado ao processador baseline. / Embedded processors rely on the efficient use of instruction-level parallelism to answer the performance and energy needs of modern applications. Though improving performance is the primary goal for processors in general, it might lead to a negative impact on energy consumption, a particularly critical constraint for current systems. In this dissertation, we present SoMMA, a software-managed memory architecture for embedded multi-issue processors that can reduce energy consumption and energy-delay product (EDP), while still providing an increase in memory bandwidth. We combine the use of software-managed memories (SMM) with the data cache, and leverage the lower energy access cost of SMMs to provide a processor with reduced energy consumption and EDP. SoMMA also provides a better overall performance, as memory accesses can be performed in parallel, with no cost in extra memory ports. Compiler-automated code transformations minimize the programmer’s effort to benefit from the proposed architecture. Our experimental results show that SoMMA is more energy- and performance-efficient not only for the processing cores, but also at full-system level. Comparisons were done using the VEX processor, a VLIW reconfigurable processor. The approach shows average speedups of 1.118x and 1.121x, while consuming up to 11% and 12.8% less energy when comparing two modified processors and their baselines. SoMMA also shows reduction of up to 41.5% on full-system EDP, maintaining the same processor area as baseline processors. Lastly, even with SoMMA halving the data cache size, we still reduce the number of data cache misses in comparison to baselines.