Routines and Applications of Symbolic Algebra Software

Computing has become an essential resource in modern research and has found application across a wide range of scientific disciplines. Developments in symbolic algebra tools have been particularly valuable in physics where calculations in fields such as general relativity, quantum field theory and physics beyond the standard model are becoming increasing complex and unpractical to work with by hand. The computer algebra system Cadabra is a tensor-first approach to symbolic algebra based on the programming language Python which has been used extensively in research in these fields while also having a shallow learning curve making it an excellent way to introduce students to methods in computer algebra. The work in this thesis has been concentrated on developing Cadabra, which has involved looking at two different elements which make up a computer algebra program. Firstly, the implementation of algebraic routines is discussed. This has primarily been focused on the introduction of an algorithm for detecting the equivalence of tensorial expressions related by index permutation symmetries. The method employed differs considerably from traditional canonicalisation routines which are commonly used for this purpose by using Young projection operators to make such symmetries manifest. The other element of writing a computer algebra program which is covered is the infrastruc- ture and environment. The importance of this aspect of software design is often overlooked by funding committees and academic software users resulting in an anti-pattern of code not being shared and contributed to in the way in which research itself is published and promulgated. The focus in this area has been on implementing a packaging system for Cadabra which allows the writing of generic libraries which can be shared by the community, and interfacing with other scientific computing packages to increase the capabilities of Cadabra

Liberating Coroutines: Combining Sequential and Parallel Execution

Concurrent programming using threads is considered a hard and error-prone task. Coroutines are conceptually simpler, they are easier to program with due to their sequential nature. Flexible coroutines as presented by Belsnes and Østvold liberate classical coroutines from their quasi-parallel world and combine them with threads. This allows the programmer to factor programs into sequential and parallel tasks, leading to simpler programs. This thesis presents an extension to the formal semantics for flexible coroutines. A detailed breakdown of the scheduling strategies and parameter passing is presented in the same formal framework. Some words are given on patterns that emerge when programming with flexible coroutines and these patterns are defined in the formal framework. We present a clean implementation of flexible coroutines in Java, based on standard threads and semaphores. Challenges encountered, such as representing coroutines in Java and invoking methods across threads are discussed. This framework is used in examples that employ flexible coroutines in different ways; the classical synchronization problem of readers and writers, the Santa Claus problem and binary and general semaphores

Increasing the Performance and Predictability of the Code Execution on an Embedded Java Platform

This thesis explores the execution of object-oriented code on an embedded Java platform. It presents established and derives new approaches for the implementation of high-level object-oriented functionality and commonly expected system services. The goal of the developed techniques is the provision of the architectural base for an efficient and predictable code execution. The research vehicle of this thesis is the Java-programmed SHAP platform. It consists of its platform tool chain and the highly-customizable SHAP bytecode processor. SHAP offers a fully operational embedded CLDC environment, in which the proposed techniques have been implemented, verified, and evaluated. Two strands are followed to achieve the goal of this thesis. First of all, the sequential execution of bytecode is optimized through a joint effort of an optimizing offline linker and an on-chip application loader. Additionally, SHAP pioneers a reference coloring mechanism, which enables a constant-time interface method dispatch that need not be backed a large sparse dispatch table. Secondly, this thesis explores the implementation of essential system services within designated concurrent hardware modules. This effort is necessary to decouple the computational progress of the user application from the interference induced by time-sharing software implementations of these services. The concrete contributions comprise a spill-free, on-chip stack; a predictable method cache; and a concurrent garbage collection. Each approached means is described and evaluated after the relevant state of the art has been reviewed. This review is not limited to preceding small embedded approaches but also includes techniques that have proven successful on larger-scale platforms. The other way around, the chances that these platforms may benefit from the techniques developed for SHAP are discussed

The birth of Simula

Impagliazzo, Arne Sølvberg. Abstract. When designing Simula, Ole-Johan Dahl and Kristen Nygaard introduced the basic concepts of what later became known as object-orientation, which still, 35 years later, has a profound impact on computing. This paper looks at the background for the Simula project, how it developed over time, and why it could be so successful. Keywords: History of programming languages, Simula