The functionality of the recently announced Microsoft .NET system is founded on the capabilities of the Common Language Infrastructure (CLI). Unlike some other recent systems based on virtual machines, the CLI was designed from the start to support a wide range of programming languages. It is also expected that ECMA standardization will make the CLI available on a wide range of computing platforms. This combination of multi-language capability and multiplatform implementation make the CLI an important target for future language compilers.

The run-time characteristics of Java, such as high frequency of method invocation, dynamic dispatching and dynamic loading, make Java more difficult than other object-oriented programming languages, such as C++, for conducting Worst-Case Execution Time (WCET) analysis. To offer a more flexible way to develop object-oriented real-time applications in the realtime Java environment without loss of predicability and performance, we propose a novel gain time reclaiming framework integrated with WCET analysis. This paper demonstrates how to improve the utilisation and performance of the whole system by reclaiming gain time at run-time. Our approach shows that integrating WCET with gain time reclaiming can not only provide a more flexible environment, but it also does not necessarily result in unsafe or unpredictable timing behaviour.

We provide a systematic transformation of an LL(1) grammar to an object model that consists of • an object structure representing the non-terminal symbols and their corresponding grammar production rules, • a union of classes representing the terminal symbols (tokens). We present a variant form of the visitor pattern and apply it to the above union of token classes to model a predictive recursive descent parser on the given grammar. Parsing a non-terminal is represented by a visitor to the tokens. For non-terminals that have more than one production rule, the corresponding visitors are chained together according to the chain of responsibility pattern in factory pattern, where each concrete factory corresponds to a nonterminal symbol, is used to manufacture appropriate parsing visitors. Our object-oriented formulation for predictive recursive descent parsing eliminates the traditional construction of the predictive parsing table and yields a parser that is declarative and has minimal conditionals. It not only serves to teach standard techniques in parsing but also as a non-trivial exercise of object modeling for objects-first introductory courses.

Syntax . . . . . . . . . . . . . . . 86 5.4.2 Pretty Printing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 5.4.3 Typing and Type Checking . . . . . . . . . . . . . . . . . . . . . . . . 90 5.4.4 Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93 5.4.5 Label Generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 5.4.6 Code Generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 6 Type Systems 107 6.1 Why typing? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107 6.1.1 Avoiding run-time errors . . . . . . . . . . . . . . . . . . . . . . . . . . 107 6.1.2 E#ciency of code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 6.1.3 E#ciency of Development . . . . . . . . . . . . . . . . . . . . . . . . . 110 6.2 Type Checking versus Type Inferencing . . . . . . . . . . . . . . . . . . . . . 110 6.3 Type Language . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 6.3.1 Basic Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111 6.3.2 Composite Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112 6.4 Type Inferencing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 6.4.1 Type Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 6.4.2 Type derivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115 6.5 Polymorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 6.5.1 Substitution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 6.5.2 Unification . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119 6.5.3 Type Rules For Polymorphism . . . . . . . . . . . . . . . . . . . . ...

Abstract. Loop optimizations such as loop unrolling, unfolding and invariant code motion have long been used in a wide variety of compilers to improve the running time of applications. In this paper we present a series of experimental results detailing the effect these techniques have on the running time of Java applications following ahead of time optimization. We also detail the optimization tools and transformations developed for this paper which extend the SOOT framework discussed in a number of previous papers on the subject. Our experimentation, conducted on the SciMark 2.0 benchmarking suite, demonstrates that when optimized using the techniques mentioned, Java applications can benefit from performance improvements of up to 20%. We finish with a discussion of the results obtained, including results on how the optimizations affect JIT compilation and class size and proceed to argue that ahead-of-time loop unrolling and unfolding optimization may have a role to play in improving the performance of Java applications, particularly in scientific applications. 1

The compilation of C ♯ requires a flow analysis to ensure that every local variable is definitely assigned when any access to its value occurs. A variable is definitely assigned at a use of its value if every execution path leading to that use contains an assignment to the variable. Since local variables are uninitialized by default, this prevents access to uninitialized memory which is a crucial ingredient for the type safety of C♯. We formalize the rules of the definite assignment analysis of C ♯ with data flow equations and we prove the correctness of the analysis, i.e. if the analysis will infer a local variable as definitely assigned at a certain program point, then the variable will actually be initialized at that point during every execution of the program. We actually prove more than correctness: we show that the solution of the analysis is a perfect solution (and not only a safe approximation). 1

Abstract not found

I hereby declare that this thesis has not been submitted, either in the same or different form, to this or any other university for a degree.

Functional programming is a programming paradigm like object-oriented programming and logic programming. Functional programming comprises both a specific programming style and a class of programming languages that encourage and support this programming style. Functional programming enables the programmer to describe an algorithm on a high-level, in terms of the problem domain, without having to deal with machine-related details. A program is constructed from functions that only map inputs to outputs, without any other effect on the program state. Thus a function will always return the same output, regardless of when and in which context the function is used. These functions provide clear interfaces, separate concerns and are easy to reuse. A small and simple set of highly orthogonal language constructs assists in writing modular programs. 1

Abstract. The distribution and coordination of policies is often overlooked but is crucial to the scalability of dynamic, personalised services. In this work we partition an Abstract Syntax Tree of the policies to determine the responsibility of different management nodes in a geographically segregated network (i.e. management by delegation). This partitioning is combined with IN/OUT set analysis to determine the required coordination for policy enforcement of complex policies with inter-dependencies. Our simulation results show that this approach is promising, as higher decision loads can be readily handled by further sub-dividing of the network. 1