Tasking and systems programming

The Ada† programming language defines the semantics of interrupt handling as part of the tasking mechanism, making it possible to construct implementation‐independent interrupt handlers. However, for the Ada mechanism to be effective, an implementation must provide support not specified by the Ada standard, such as for initializing hardware interrupting devices, handling unexpected interrupts and optimizing for real‐time performance constraints. This paper analyses some of the constraints that efficient interrupt support places on an implementation. It develops a model for the interaction between interrupt hardware and Ada tasks and describes optimizations for Ada interrupt handlers. Implementation issues, including task priorities and task termination for interrupt handlers, are discussed in detail.

We propose quantitative regular expressions (QREs) as a high-level programming abstraction for specifying complex numerical queries over data streams in a modular way. Our language allows the arbitrary nesting of orthogonal sets of combinators: (a) generalized versions of choice, concatenation, and Kleene-iteration from regular expressions, (b) streaming (serial) composition, and (c) numerical operators such as min, max, sum, difference, and averaging. Instead of requiring the programmer to figure out the low-level details of what state needs to be maintained and how to update it while processing each data item, the regular constructs facilitate a global view of the entire data stream splitting it into different cases and multiple chunks. The key technical challenge in defining our language is the design of typing rules that can be enforced efficiently and which strike a balance between expressiveness and theoretical guarantees for well-typed programs. We describe how to compile each QRE into an efficient streaming algorithm. The time and space complexity is dependent on the complexity of the data structure for representing terms over the basic numerical operators. In particular, we show that when the set of numerical operations is sum, difference, minimum, maximum, and average, the compiled algorithm uses constant space and processes each symbol in the data stream in constant time outputting the cost of the stream processed so far. Finally, we prove that the expressiveness of QREs coincides with the streaming composition of regular functions, that is, MSO-definable string-to-term transformations, leading to a potentially robust foundation for understanding their expressiveness and the complexity of analysis problems.

We propose a simplified high-level programming language based on blocks and links dragged on a workspace which generates the skeleton code for robotic applications involving different types of robots. In order to develop such a high-level programming language that still can guarantee flexibility in term of implementation, our approach takes advantage of the robot operating system (ROS). ROS is a open source meta-operating system that provides a message passing structure between different processes (or nodes) across a network (inter-process communication). In our framework, we consider a hierarchical approach in which at the base there is ROS that allows inter-process communication between nodes in a robot and on the top we create a high-level language that interacts with ROS and thus with the real robot. The high-level language can be viewed as an extra layer added to simplify lower level code generation.

: This report gives a detailed description of parsing and dimensionality propagation for the Equational Programming Language compiler. The Equational Programming Language, called EPL, is a very high-level declarative language designed to specify parallel and real-time computations. The EPL compiler translates equational specifications into procedural, high level language (currently C). The compiler itself is written in C for UNIX based systems. Automated tools YACC and LEX has been used for lexical analysis and parsing. Detailed description is given of the design and implementation of the algorithms for building different structures (such as symbol table, equation trees, etc.). These structures are used by subsequent post-parsing analysis and code-generation phases of the EPL compiler. The description of the algorithm for dimensionality propagation is also included.

GPUs and other accelerators are popular devices for accelerating compute-intensive, parallelizable applications. However, programming these devices is a difficult task. Writing efficient device code is challenging, and is typically done in a low-level programming language. High-level languages are rarely supported, or do not integrate with the rest of the high-level language ecosystem. To overcome this, we propose compiler infrastructure to efficiently add support for new hardware or environments to an existing programming language. We evaluate our approach by adding support for NVIDIA GPUs to the Julia programming language. By integrating with the existing compiler, we significantly lower the cost to implement and maintain the new compiler, and facilitate reuse of existing application code. Moreover, use of the high-level Julia programming language enables new and dynamic approaches for GPU programming. This greatly improves programmer productivity, while maintaining application performance similar to that of the official NVIDIA CUDA toolkit.

Compiler design plays an important role in ensuring that the translation of the programs written in high-level language into executable code is correct. However, in todays’ safety-critical environments, security gaps, visible and hidden defects in compiler models are liability factors that needed to be addressed in the process of examining that a system meets specifications and requirements of its intended objectives. Nevertheless, defects in this model are errors in coding which bring about incorrect or unexpected results from a compiler design that does not meet the actual requirements. Hence, this paper developed a novel approach by integrating the computational power of Communicating Stream X-Machine (CSXM) to address the problem associated with compiler correctness. In addition, this paper outlines the development of a novel compiler design called X-compiler, emphasizing its important role in software development. CSXM technique was implemented in Visual Studio (2022) to develop the X-compiler. The X-compiler utilize state-of-the-art techniques to translate program source code written in high-level programming language which is the blend of C# and Python programming language into executable code. The development process includes the lexical analysis, syntax parsing, semantic analysis, and code generation ensuring the correctness of the X-compiler. The results of the compiled code were run to produce output in command Windows environment for user interactions. Also, highlights the potential for enhanced language interoperability and the development of efficient compiler that leverage the strengths of multiple programming paradigms. Overall, the study on CSXM contributed to a deeper understanding of concurrent systems, while the design and implementation of the compiler showcased the feasibility of creating a synergistic blend of C# and Python programming languages.

Hydrologists need simple, yet powerful, open source framework for developing and testing mathematical models. Such framework should ensure long-term interoperability and high scalability. This can be done by implementation of the existing, already tested standards. At the moment two interesting options exist: Open Modelling Interface (OpenMI) and Object Modeling System (OMS). OpenMI was developed within the Fifth European Framework Programme for integrated watershed management, described in the Water Framework Directive. OpenMI interfaces are available for the C# and Java programming languages. OpenMI Association is now in the process of agreement with Open Geospatial Consortium (OGC), so the spatial standards existing in OpenMI 2.0 should be better implemented in the future. The OMS project is pure Java, object-oriented modeling framework coordinated by the U.S. Department of Agriculture. Big advantage of OMS compared to OpenMI is its simplicity of implementation. On the other hand, OpenMI seems to be more powerful and better suited for hydrological models. Finally, OpenMI model was selected as the base interface for the proposed open source hydrological framework. The existing hydrological libraries and models focus usually on just one GIS package (HydroFOSS – GRASS) or one operating system (HydroDesktop – Microsoft Windows). The new hydrological framework should break those limitations. To make hydrological models’ implementation as easy as possible, the framework should be based on a simple, high-level computer language. Low and mid-level languages, like Java (SEXTANTE) or C (GRASS, SAGA) were excluded, as too complicated for regular hydrologist. From popular, high-level languages, Python seems to be a good choice. Leading GIS desktop applications – GRASS and QGIS – use Python as second native language, providing well documented API. This way, a Python-based hydrological library could be easily integrated with any GIS package supporting this programming language. As the OpenMI 2.0 standard supported interfaces only for Java and C#, the Python interface for OpenMI standard, presented in this paper, is the first step done towards the open and interoperable hydrological framework. GIS-related issues of the OpenMI 2.0 standard are also outlined and discussed.

Incorporating user-oriented features usually found only in much larger computers, the first models of the Eclipse line, the $100 and $200, use a high speed micro-programmed central processor, and can run with either; core or semiconductor memories, or both. The core and semiconductor memories are available with an error detection and correction feature that can find and correct; single bit errors caused by the computer. The semiconductor memories use a high-speed cache to increase memory speed. The Eclipse $100, the smaller of the two computers, will be used by oems or by end users who need a smaller system to meet their requirements. The Eclipse $100 is 5-1/4 inches high, and holds six standard Data General printed circuit boards. It costs $9200, with 16k bytes of core memory, and $10,700 with 16k bytes of semiconductor memory. Eclipse $100 deliveries will begin in December. The Eclipse $200, a system-oriented computer that can hold 16 printed circuit boards, will be used by system builders or end users who will build large scale computing systems around it. The Eclipse $200 is 10-1/2 inches high, and costs $16,300 with 32k bytes of core memory, and $19,300 with 32k bytes of semiconductor memory. Deliveries of the Eclipse $200 will begin in February. The instruction set of both Eclipse computers is microprogrammed in the central processor. There are over 40 new instruction in the Eclipse computers. Programs written on Nova computers will run on either the Eclipse $100 or $200. The central processor includes a Writeable Control Store making up to 256, 56-bit words available to write specialized micro-programmed instructions. The instruction set is enhanced to help programmers writing in assembly language or high-level language programs. Hardware memory stacks, supported by comprehensive instructions, make programming more efficient, while block, word, byte and bit manipulation instructions improve system performance. Instructions are both single word and double word instructions.

This thesis presents research to build and evaluate embedding of a textual form of state machines into high-level programming languages. The work entailed adding state machine syntax and code generation to the Umple model-oriented programming technology. The added concepts include states, transitions, actions, and composite states as found in the Unified Modeling Language (UML). This approach allows software developers to take advantage of the modeling abstractions in their textual environments, without sacrificing the value added of visual modeling. Our efforts in developing state machines in Umple followed a test-driven approach to ensure high quality and usability of the technology. We have also developed a syntax-directed editor for Umple, similar to those available to other high-level programming languages. We conducted a grounded theory study of Umple users and used the findings iteratively to guide our experimental development. Finally, we conducted a controlled experiment to evaluate the effectiveness of our approach. By enhancing the code to be almost as expressive as the model, we further support model-code duality; the notion that both model and code are two faces for the same coin. Systems can be and should be equally-well specified textually and diagrammatically. Such duality will benefit both modelers and coders alike. Our work suggests that code enhanced with state machine modeling abstractions is semantically equivalent to visual state machine models. The flow of the thesis is as follows; the research hypothesis and questions are presented in “Chapter 1: Introduction”. The background is explored in “Chapter 2: Background”. “Chapter 3: Syntax and semantics of simple state machines” and “Chapter 4: Syntax and semantics of composite state machines” investigate simple and composite state machines in Umple, respectively. “Chapter 5: Implementation of composite state machines” presents the approach we adopt for the implementation of composite state machines that avoids explosion of the amount of generated code. From this point on, the thesis presents empirical work. A grounded theory study is presented in “Chapter 6: A Grounded theory study of Umple”, followed by a controlled experiment in “Chapter 7: Experimentation”. These two chapters constitute our validation and evaluation of Umple research. Related and future work is presented in “Chapter 8: Related work”.

The level of support for high level programming languages (HLPLs), despite the claim of support by some of the newly introduced microprocessors, is inadequate despite the falling (rising) cost of hardware (software). Computer systems that are to be used to run programs written exclusively in HLPLs have a need for a multiprocessor/multiarchitecture microprocessor design (M3D); the personal/desk-top computers are prime examples. The HLPLs that will be used in programming these systems will be grouped according to their structures. Each group of languages will require their own instruction set; the hardware and software needs will determine the type of architecture configuration, i.e. aspects such as: register-to-register, memory-to-memory, stack, or a combination of these. The overall system should be divided up into functional units, e.g. ALU, compiler/translator, etc. Each functional or subfunctional unit will be implemented in software, firmware, hardware, or a combination of these with implementation decision based on the speed criticality, cost, technology, and the need to modify the unit. This approach will lead to a cop-down-design, and will also reduce the semantic gap, software and system cost, and down-time.

We execute the quantum eraser, the Elitzur–Vaidman bomb, and the Hardy’s paradox experiment using high-level programming language on a generic, gate-based superconducting quantum processor made publicly available by IBM. The quantum circuits for these experiments use a mixture of one-qubit and multi-qubit gates and require high entanglement gate accuracy. The results aligned with theoretical predictions of quantum mechanics to high confidence on circuits using up to 3 qubits. The power of quantum computers and high-level language as a platform for experimenting and studying quantum phenomena is henceforth demonstrated.

In this paper we advocate that it is time for a radical rethinking of database systems design. Developers should be able to leverage high-level programming languages without having to pay a price in efficiency. To realize our vision of abstraction without regret , we present LegoBase, a query engine written in the high-level programming language Scala. The key technique to regain efficiency is to apply generative programming: the Scala code that constitutes the query engine, despite its high-level appearance, is actually a program generator that emits specialized, low-level C code. We show how the combination of high-level and generative programming allows to easily implement a wide spectrum of optimizations that are difficult to achieve with existing low-level query compilers, and how it can continuously optimize the query engine. We evaluate our approach with the TPC-H benchmark and show that: (a) with all optimizations enabled, our architecture significantly outperforms a commercial in-memory database system as well as an existing query compiler, (b) these performance improvements require programming just a few hundred lines of high-level code instead of complicated low-level code that is required by existing query compilers and, finally, that (c) the compilation overhead is low compared to the overall execution time, thus making our approach usable in practice for efficiently compiling query engines.

If you really want to get to the “heart” of a computer system then it is necessary to learn to talk to it in, as near as possible, a language that it understands. Using high-level programming languages such as MBASIC means that you are talking to the computer through an interpreter and hence all the instructions that you issue in a program take that much longer to be carried out. That is why we use a compiler; see chapter 8. But even if we use a compiled language we cannot control a number of aspects of the computer’s operation at what we could call the “bit level”. This is the lowest level of communication with the microprocessor and in the past, when computers were still in their infancy, this was the only way of programming. It was actually performed in the binary code of zeros and ones. This is not surprising since this is the only kind of code that the processor understands. High-level languages have taken a lot of the hard work out of programming, but a lot of detail has been lost on the way.

Abstraction without regret refers to the vision of using high-level programming languages for systems development without experiencing a negative impact on performance. A database system designed according to this vision offers both increased productivity and high performance instead of sacrificing the former for the latter as is the case with existing, monolithic implementations that are hard to maintain and extend. In this article, we realize this vision in the domain of analytical query processing. We present LegoBase, a query engine written in the high-level programming language Scala. The key technique to regain efficiency is to apply generative programming: LegoBase performs source-to-source compilation and optimizes database systems code by converting the high-level Scala code to specialized, low-level C code. We show how generative programming allows to easily implement a wide spectrum of optimizations, such as introducing data partitioning or switching from a row to a column data layout, which are difficult to achieve with existing low-level query compilers that handle only queries. We demonstrate that sufficiently powerful abstractions are essential for dealing with the complexity of the optimization effort, shielding developers from compiler internals and decoupling individual optimizations from each other. We evaluate our approach with the TPC-H benchmark and show that (a) with all optimizations enabled, our architecture significantly outperforms a commercial in-memory database as well as an existing query compiler. (b) Programmers need to provide just a few hundred lines of high-level code for implementing the optimizations, instead of complicated low-level code that is required by existing query compilation approaches. (c) These optimizations may potentially come at the cost of using more system memory for improved performance. (d) The compilation overhead is low compared to the overall execution time, thus making our approach usable in practice for compiling query engines.

Security types preserving compilation