Location of Repository

A synchronous concurrent algorithm is an algorithm that is described as a network of intercommunicating processes or modules whose concurrent actions are synchronised with respect to a global clock. Synchronous algorithms include systolic algorithms; these are algorithms that are well-suited to implementation in VLSI technologies.\ud \ud This thesis provides a mathematical theory for the design and analysis of synchronous algorithms. The theory includes the formal specification of synchronous algorithms; techniques for proving the correctness and performance or time-complexity of synchronous algorithms, and formal accounts of the simulation and top-down design of synchronous algorithms.\ud \ud The theory is based on the observation that a synchronous algorithm can be specified in a natural way as a simultaneous primitive recursive function over an abstract data type; these functions were first studied by J. V. Tucker and J. I. Zucker. The class of functions is described via a formal syntax and semantics, and this leads to the definition of a functional algorithmic notation called PR. A formal account of synchronous algorithms and their behaviour is achieved by showing that synchronous algorithms can be specified in PR. A formal account of the performance of synchronous algorithms is achieved via a mathematical account of the time taken to evaluate a function defined by simultaneous primitive recursion.\ud \ud A synchronous algorithm, when specified in PR, can be transformed into a program in a language called FPIT. FPIT is a language based on abstract data types and on the multiple or concurrent assignment statement. The transformation from PR to FPIT is phrased as a compiler that is proved correct; compiling the PR-representation of a synchronous algorithm thus yields a provably correct simulation of the algorithm. It is proved that FPIT is just what is needed to implement PR by defining a second compiler, this time from FPIT back into PR, which is again proved correct, and thus PR and FPIT are formally\ud computationally equivalent. Furthermore, an autonomous account of the length of computation of FPIT programs is given, and the two compilers are shown to be performance preserving; thus PR and FPIT are computationally equivalent in an especially strong sense.\ud \ud The theory involves a formal account of the top-down design of synchronous algorithms that is phrased in terms of correctness and performance preserving transformations between synchronous algorithms specified at different levels of data abstraction. A new definition of what it means for one abstract data type to be 'implemented' over another is given. This definition generalises the idea of a computable algebra due to A. I. Mal'cev and M. 0. Rabin. It is proved that if one data type D is implementable over\ud another data type D', then there exists correctness and performance preserving compiler mapping high level PR-programs over D to low level PR-programs over D'.\ud \ud The compilers from PR to FPIT and from FPIT to PR are defined explicitly, and our compilerexistence\ud proof is constructive, and so this work is the basis of theoretically well-founded software tools\ud for the design and analysis of synchronous algorithms

Publisher: School of Computing (Leeds)

Year: 1987

OAI identifier:
oai:etheses.whiterose.ac.uk:945

Provided by:
White Rose E-theses Online

Downloaded from
http://etheses.whiterose.ac.uk/945/1/uk_bl_ethos_379746.pdf

- A
- (1981). A 32-bit VLSI Chip",
- (1980). A Calculus of Communicating Systems,
- (1980). A Complexity Theory for VLSI",
- (1979). A Computational Logic,
- (1985). A Derivation of a Distributed Implementation of Warshall's Algorithm",
- (1976). A Discipline of Programming,
- (1983). A Formal Basis for the Analysis of Circuit Timing",
- (1986). A Formal Model for the Hierarchical Design of Synchronous and Systolic Algorithms",
- A Formulation of the Simple Theory of Types",
- (1987). A Graph-Theoretic Model of Synchronous Computation".
- (1943). A Logical Calculus of the Ideas Immanent in Nervous Activity",
- (1984). A Mathematical Model for the Verification of Systolic Networks",
- (1984). A Switch-Level Simulator for MOS Digital Systems",
- (1987). A Systolic Algorithm for Matrix-Vector Multiplication",
- (1984). A Taxonomy of Parallel Sorting",
- (1983). A Temporal Logic for Multi-Level Reasoning About Hardware",
- (1985). A Transformational Model of VLSI Systolic Design",
- (1981). A Wavefront Notation Tool for VLSI Array Design",
- (1984). ADVIS: A Software Package for the Design of Systolic Arrays",
- Algebra of Communicating Processes",
- (1968). Algebraic Properties of Structures",
- (1986). Algebraic Specifications of Computable and Semicomputable Data Types",
- (1986). Algorithmic Procedures, Generalised Turing Algorithms, and Elementary Recursion Theory",
- (1983). An Algebra for VLSI Algorithm Design",
- (1986). An example of stepwise refinement of distributed programs: quiescence detection",
- An Experimental Study of a Timing Assumption in VLSI Complex.
- (1978). An Initial Algebra Approach to the Specification, Correctness and Implementation of Abstract Data Types",
- (1986). An Investigation into the Role of PRO in Laying Out Synchronous Systems",
- (1983). Automatic and Hierarchical Verification of Circuits using Temporal Logic",
- (1983). Bibliography on abstract data types.
- (1987). Boltzmann Machines and their Applications",
- Can Programming be Liberated from the von Neumann Style? A Functional Style and its Algebra of Programs",
- (1968). Cellular Automata,
- (1982). CIRCAL: A Calculus for Circuit Description",
- (1985). Communicating Sequential Processes, Prentice-Hall International,
- (1982). Complexity Theory and the Operational Structure of Algebraic Programming Systems",
- (1960). Computable Algebra, General Theory and the Theory of Computable Fields",
- (1961). Constructive Algebras",
- (1983). Design and Complexity of VLSI Algorithms",
- (1986). Design Transformation and Chip Planning",
- (1956). Effective Procedures in Field Theory",
- (1987). Efficient Systolic Arrays for the Solution of Toeplitz Systems: An Illustration of a Methodology for the Construction of Systolic Architectures in VLSI",
- (1983). Equivalence of The Arbiter, The Synchronizer, The Latch, and The Inertial Delay",
- (1986). Executing Temporal Logic Program,
- (1987). Formal Verification and Implementation of a Microprocessor", in
- (1985). Fundamentals of Algebraic Specification I- Examples and Initial Semantics",
- (1980). Hardware Specification with Temporal Logic: An Example",
- (1986). Hardware Verification using Higher-Order Logic",
- (1987). Hardware Verification Workshop,
- (1984). Hoare Logics for the Run-Time Analysis of Programs",
- (1987). HOL: A Proof Generating System for Higher-Order Logic", in
- (1980). HOPE: An Experimental Applicative Language",
- (1985). Initiality, Induction, and Computability",
- (1980). Introduction to VLSI Systems, Addison-Wesley
- (1961). Iterative Arrays of Logical Circuits,
- (1977). Microelectronics and Computer Science",
- (1987). Models and Logics for MOS Circuits", in
- More Advice On Structuring Compilers and Proving Them Correct",
- (1983). North-Holland,
- (1936). On Computable Numbers, with an Application to the Entscheidungsproblem",
- (1985). On Mapping Homogeneous Graphs on a Linear Array-processor Model",
- (1986). On Synthesising Systolic Arrays form Recurrence Equations with Linear Dependencies",
- On the Specification, Implementation, and Verification of Data Types",
- (1983). Optimising Synchronous Systems",
- (1987). Overview of SAGA and CONDENSE",
- (1987). Papers of John von
- (1985). Parallel Sorting Algorithms,
- (1983). Partially Ordered Computations, with Applications to VLSI Design",
- (1986). Partitioning and Mapping Algorithms onto Fixed Size VLSI Algorithms",
- (1969). Perceptrons: An Introduction to Computational Geometry,
- (1973). Principles of Programming Languages,
- (1987). Program Correctness over Abstract Data Types with Error-State Semantics, North-Holland (in press),
- (1986). Proving Systolic Algorithms Correct",
- (1983). Reasoning About Synchronous Systems",
- (1967). Recursive Functions,
- References to the Literature on VLSI Algorithmics and Related Mathematical and Practical Issues",
- (1980). Semantics Directed Compiler Generation, Springer-Verlag (LNCS 259),
- (1968). Sorting Networks and Their Applications",
- (1984). Spacetime Representations of Systolic Computational Structures",
- (1985). Special-Purpose VLSI Architectures: General Discussion and a Case Study",
- (1983). Specification and Proof of a Regular Language Recogniser in Synchronous CCS",
- (1986). Specification and Verification using Higher-Order Logic: A Case Study",
- (1987). Specification, Derivation, and Verification of Concurrent Line Drawing Algorithms and Architectures",
- (1982). Springer-Verlag (LNCS 201),
- (1987). Springer-Verlag (LNCS 258),
- (1980). Springer-Verlag (LNCS 259),
- (1984). Synthesis of Digital Circuits from Recursion Equations,
- (1987). Synthesis of Systolic Arrays for Inductive Problems",
- (1986). Synthesising Non-uniform Systolic Designs",
- (1987). Synthesising Systolic Arrays using DIASTOL",
- (1980). System Timing, (Chapter 7 of Mead and Conway [1980].
- Systolic Algorithms as Programs".
- Systolic Array Synthesis by Static Analysis of Program Dependencies",
- (1979). Systolic Arrays (for VLSI)",
- (1981). Temporal Specification of Self-Timed Systems",
- (1967). The Complexity of Loop Programs,
- (1987). The Concurrent Assignment Representation of Synchronous Systems",
- (1985). The Design of Optimal Systolic Arrays",
- (1986). The FM5801: A Verified Microprocessor",
- (1987). The Formal Specification of a Digital Correlator I: Abstract User Process",
- (1963). The Main Features of CPL",
- (1978). The Multiple Assignment Statement",
- (1967). The Organisation of Computations for Uniform Recurrence Equations",
- The Systematic Design of Systolic Arrays",
- (1984). The VERITAS Theorem-Prover and its Formal Specification",
- Theoretical Considerations in Algorithm Design",
- (1975). Theory of Program Structures: Schemes, Semantics, Verification, Springer-Verlag (LNCS 36),
- (1984). Unifying VLSI Array Design with Linear Transformations of Space-Time",
- (1888). Was Sind und Was Sollen die Zahlen?,
- (1982). Why Systolic Architectures? ",
- (1982). Winning Ways,
- (1983). µFP: An Algebraic Design Language", PhD. Thesis,

To submit an update or takedown request for this paper, please submit an Update/Correction/Removal Request.