Abstract
Complex applications in distributed-memory parallel systems often follow a demand-driven approach with domain decomposition. A uniform data distribution among the local memories at the processing elements may require frequent remote data access. To keep the processors busy while data is remotely fetched, concurrent application processes are assigned to each transputer-based processing element. Adding more concurrent application processes in a large-scale parallel system may degrade performance, due to the traffic increase with data requests and data block replies. A conditional broadcast mechanism is implemented during data requests, to limit this flow of messages. Monitoring strategies are proposed to further reduce the messages density, and a parameterized model to measure and evaluate global execution times is presented. Simulation data running the model with up to 35 transputers show that monitoring can reduce the performance degradation when more local concurrence is added. However, if too much data replication is present, the simulation data also show that the supply of communication services at each node still imposes a burden, requiring complementary monitoring strategies to allow removal of redundant reply messages.

Abstract
This paper describes CA/C++, Concurrency Annotations in C++, a language extension that regulates method invocations from multiple threads of execution in a shared-memory multiprocessor system. This system provides threads as an orthogonal element to the language, allowing them to travel through more than one object. Statically type-ckecked synchronous and asynchronous method invocations are supported, with return values from asynchronous invocations accessed through first claw future-like objects. Method invocations are regulated with synchronization code defined in a separate class hierarchy, allowing separate definition and inheritance of synchronization mechanisms. Each method is protected by an access flag that can be switched in pre and post-actions, and by a predicate. Both must evaluate to true in order to enable a thread to animate the method code. Flags and method predicates are independently redefinable along the inheritance chain, thus avoiding the inheritance anomaly.

Abstract
By adopting theories as primitive components of a logic and recognizing that formulae are just presentation details we arrive at the concept of topological institution. In a topological institution, we have, for each signature, a frame of theories, a set of interpretation structures and a satisfaction relation. More precisely, we have, for each signature, a topological system. We show how to extract a topological institution from a given institution and establish an adjunction. Illustrations are given within the context of equational logic. We study the compositionality of theories. Formulae are recovered when we establish a general technique for presenting topological institutions. Topological institutions with finitely observable theories are shown to be useful in temporal monitoring applications where we would like to be able to characterize the properties of the system that can be monitored. Namely, an invariant property (Gf) cannot be monitored because it cannot be positively established in finite time. On the contrary, a reactivity property (Ff) can be positively established in finite time. © Springer-Vedag Berlin Heidelberg 1995.

Abstract

Abstract
Theoretical computer science has the aim of formalizing previous empirical, innovative creations in computing, by developing formal methods and models for their description, analysis and design. Formal methods emerged in software engineering as the mathematical support needed for software systems description, design and verification, offering abstract formalisms and domains of models. Interactive software systems design, due to the principle of separation, has been split into two distinct design and implementation processes, one concerned with the computational subsystem, the other addressing the interactive one. However, formal methods have been applied, almost exclusively, in the design of the computational layer. The design of the interactive layer is mainly concerned with the design of the User Interface (UI) of the system or application. Despite its recognized importance and complexity, UI design is still being done on a technological basis and using ad hoc methods. Therefore, it is time to devolve upon user-interface software design the acknowledged benefits derived from the use of formal methods. In this paper, we start by formalizing mechanisms to be embedded in an UI model, appropriate to cope with some characteristics of user input-behaviour, namely, nondeterminism, unreliably and incompleteness. Archetypes are presented as mechanisms for the representation and treatment of incomplete user's input, an innovative step in UI design. We call assisted-user-interfaces (AUI) the class of UI based on such mechanisms. A user-interface development system for their automatic generation, ASSIST, is also described. Finally, we outline an important methodological link between the design of the two layers of an interactive system (interactive and computational). A formal specification of the application contains information that may be systematically used in the design of the relevant parts of the interactive layer. Through ASSIST that information allows for the automatic generation of the AUI. © 1990.

Abstract
This paper presents a transformational approach to the derivation of implementations from model-oriented specifications of abstract data types. The purpose of this research is to reduce the number of formal proofs required in model refinement, which hinder software development. It is shown to be applicable to the transformation of models written in META-IV (the specification language of VDM) towards their refinement into, for example, Pascal or relational DBMSs. The approach includes the automatic synthesis of retrieve functions between models, and data-type invariants. The underlying algebraic semantics is the so-called final semantics "à la Wand": a specification "is" a model (heterogeneous algebra) which is the final object (up to isomorphism) in the category of all its implementations. The transformational calculus approached in this paper follows from exploring the properties of finite, recursively defined sets. This work extends the well-known strategy of program transformation to model transformation, adding to previous work on a transformational style for operation-decomposition in META-IV. The model-calculus is also useful for improving model-oriented specifications. © 1990 BCS.