The real-time refinement calculus: A foundation for machine-independent real-time programming

The real-time refinement calculus is an extension of the standard refinement calculus in which programs are developed from a precondition plus post-condition style of specification. In addition to adapting standard refinement rules to be valid in the real-time context, specific rules are required for the timing constructs such as delays and deadlines. Because many real-time programs may be nonterminating, a further extension is to allow nonterminating repetitions. A real-time specification constrains not only what values should be output, but when they should be output. Hence for a program to implement such a specification, it must guarantee to output values by the specified times. With standard programming languages such guarantees cannot be made without taking into account the timing characteristics of the implementation of the program on a particular machine. To avoid having to consider such details during the refinement process, we have extended our real-time programming language with a deadline command. The deadline command takes no time to execute and always guarantees to meet the specified time; if the deadline has already passed the deadline command is infeasible (miraculous in Dijkstra's terminology). When such a realtime program is compiled for a particular machine, one needs to ensure that all execution paths leading to a deadline are guaranteed to reach it by the specified time. We consider this checking as part of an extended compilation phase. The addition of the deadline command restores for the real-time language the advantage of machine independence enjoyed by non-real-time programming languages.

Refinement-robust fairness

We motivate and study the robustness of fairness notions under refinement of transitions and places in Petri nets. We show that the classical notions of weak and strong fairness are not robust and we propose a hierarchy of increasingly strong, refinement-robust fairness notions. That hierarchy is based on the conflict structure of transitions, which characterizes the interplay between choice and synchronization in a fairness notion. Our fairness notions are defined on non-sequential runs, but we show that the most important notions can be easily expressed on sequential runs as well. The hierarchy is further motivated by a brief discussion on the computational power of the fairness notions.

Towards a refinement calculus for concurrent real-time programs

We define a language and a predicative semantics to model concurrent real-time programs. We consider different communication paradigms between the concurrent components of a program: communication via shared variables and asynchronous message passing (for different models of channels). The semantics is the basis for a refinement calculus to derive machine-independent concurrent real-time programs from specifications. We give some examples of refinement laws that deal with concurrency.

Introducing reference semantics via refinement

Two types of semantics have been given to object-oriented formal specification languages. Value semantics denote a class by a set of values representing its objects. Reference semantics denote a class by a set of references, or pointers, to values representing its objects. While adopting the former facilitates formal reasoning, adopting the latter facilitates transformation to object-oriented code. In this paper, we propose a combined approach using value semantics for abstract specification and reasoning, and then refining to a reference semantics before transforming specification to code.

Compilation by refinement for a practical assembly language

In this paper we extend the conventional framework of program refinement down to the assembler level. We describe an extension to the Refinement Calculus that supports the refinement of programs in the Guarded Command Language to programs in .NET assembler. This is illustrated by a small example.

Refinement of higher-order logic programs

A refinement calculus provides a method for transforming specifications to executable code, maintaining the correctness of the code with respect to its specification. In this paper we extend the refinement calculus for logic programs to include higher-order programming capabilities in specifications and programs, such as procedures as terms and lambda abstraction. We use a higher-order type and term system to describe programs, and provide a semantics for the higher-order language and refinement. The calculus is illustrated by refinement examples.

Zirconium alloying and grain refinement of magnesium alloys

Factors that influence alloying zirconium to magnesium with a Mg-33.3Zr master alloy and the subsequent grain refinement are discussed based on a large number of experiments conducted at the laboratory scale (up to 30 kg of melt). It is shown that the zirconium particles released from the Zirmax(R) master alloy must be brought into thorough contact with the melt by an appropriate stirring process in order to attain a good dissolution of zirconium. The influence of alloying temperature on the recovery of zirconium was found to be negligible in the range from 680 to 780 degreesC. An ideal zirconium alloying process should end up with both high soluble and high total zirconium in the melt in order to achieve the best grain refinement in the final alloy. The distribution of zirconium in the final alloy microstructure is inhomogeneous and almost all of the zirconium in solution is concentrated in zirconium-rich cores in the microstructure.

A new zirconium-rich master alloy for the grain refinement of magnesium alloys

A new zirconium-rich magnesium-zirconium master alloy (designated AM-cast) has been developed by the CRC for Cast Metals Manufacturing in collaboration with Australian Magnesium Corporation for use as a grain refiner for magnesium alloys that do not contain aluminium. This work describes the microstructural characteristics of this new grain refiner and its grain refining ability when added to different magnesium alloys under various conditions (alloying temperature from 680 °C to 750 °C; weight of melt from 1 kg to 150 kg and sample thickness from 7 mm to 62 mm). Owing to its highly alloyable microstructure, AM-cast can be readily introduced into molten magnesium at any temperature when assisted by a few minutes of stirring or puddling. Little sludge has been found at the bottom of the alloying vessel in these trials due to the fine zirconium particles contained in the master alloy. The recovery of zirconium is normally in the range from 40% to 60% with respect to 1% zirconium addition as the master alloy. It is shown that this new master alloy is an excellent grain refiner for aluminium-free magnesium alloys.