Browsing by Author "Unger, Brian W"

Now showing 1 - 20 of 49
  • No Thumbnail Available
    ItemMetadata only
    Combined discrete and continuous simulation in ADA
    (1983-11-01) Inkster, James; Lomow, Greg; Unger, Brian W
    This paper discusses the design of an Ada package for the modelling of combined discrete and continuous systems. The package is an extended version of SAMOA, a general purpose discrete-event simulation system that uses the tasking and data abstraction constructs of Ada to provide process-oriented simulation facilities similar to those of Simula's class SIMULATION. The paper reviews the interface problems involved in combining discrete and continuous simulation, particularly the problem of co-ordinating the time advance mechanisms of the two, and describes the implementation in SAMOA of a framework that provides general and unrestricted facilities for both types of simulation and for the modelling of interactions between continuous and discrete components of a system. Other significant features of SAMOA include such user services as statistics collection, report generation, and event tracing. The paper concludes with an example of a SAMOA combined simulation that illustrates the major features of the system.
  • Thumbnail Image
    ItemOpen Access
    Communicating Sequential Prolog
    (1988-01-01) Li, Xining; Unger, Brian W; Cleary, John; Lomow, Greg; West, Darrin
    Communicating Sequential Prolog (CSP') is a single-solution distributed logic programming language for discrete event simulation. Its primary goal is to speed up the execution of logic programs through the use of parallelism, while as far as possible preserving the semantics of standard Prolog. A CSP' program consists of a set of parallel processes, synchronized by simulation time and by message passing. The underlying interprocess communication mechanism is Time Warp. The pertinent features of parallel logic programming and Time Warp are described. The syntax of CSP' is introduced and the semantics of new predicates and their control structures are discussed. Examples are given to show the expressive power and simplicity of CSP'.
  • No Thumbnail Available
    ItemMetadata only
    A course in operating system development by a team
    (1976-07-01) Unger, Brian W
    A one term course on the cooperative development of an operating system by a team of individuals is described. Operating system implementation is limited to resource allocation functions and is facilitated by using a system software design and simulation package. The course is based on a programming project which includes phases of planning, design, implementation and evaluation. Issues involved in designing the project, organizing a project team and project management are briefly discussed. Emphasis is placed on the communication problems which arise in cooperative systems programming efforts. Three experiences with teaching the course are described and it is conjectured that the major issue affecting group productivity was inter-personal communication.
  • Thumbnail Image
    ItemOpen Access
    Database concurrency control using time warp
    (1986-11-01) Zhixin, Dong; Heying, Zhou; Lomow, Greg; Unger, Brian W
    Concurrency control in a distributed database refers to mechanisms which permit multiple transactions to operate on the database simultaneously while ensuring that the database appears consistent to each transaction. Problems which need to be addressed include avoiding or recovering from deadlocked transactions and making transactions operate on a consistent database atomically. Considerable research has been done in this area and concurrency control mechanisms based on two-phase locking and two-phase commit [Hammer80], timestamps [Rosenkrantz78] [Thomas79], multiversion data objects [Reed78] and conflict analysis [Bernstein80a] [Bernstein80b] have been proposed. Each approach offers different advantages and incurs different costs. In this paper we investigate an optimistic algorithm for synchronising distributed database transactions that is based on Time Warp (TW) described by Jefferson [Jefferson85]. The database is assumed to consist of a set of long lived abstract data objects that are operated upon concurrently by a changing set of short lived objects, i.e. transactions. First, a brief outline of the TW algorithm is given, then the characteristics of a concurrency control (CC) algorithm based on TW is presented and finally, we discuss problems and advantages of this CC algorithm, and experience with a particular implementation.
  • No Thumbnail Available
    ItemMetadata only
    The design and simulation of a multi-computer network message processor
    (1981-02-01) Unger, Brian W; Bidulock, D.S.
    This paper describes a simulation language and its application to the design of a multicomputer network message processor. The language, called OASIS, provides a programming environment which facilitates the development of distributed software. Modular software, computer system hardware models, and the simulated execution of this software by the hardware models can be defined within OASIS. The network message processor supports bidirectional data transmission among terminals, host computers, and other network message processors. A modular design of this network message processor is implemented by a local network of five microcomputers communicating over a time shared bus. In this paper, OASIS is used to develop system software before network message processor hardware is available.
  • No Thumbnail Available
    ItemMetadata only
    Discrete event simulation in prolog
    (1984-11-01) Cleary, John; Goh, Kim-Siew; Unger, Brian W
    A logic programming language for simulation is presented along with several examples of its use. This language uses the same primitives as Concurrent Prolog with the addition of delay expressions in the guards. An advantage of this approach is that Concurrent Prolog programs can be prototyped and debugged via simulation after which the delay expressions can be ignored to produce the final Concurrent Prolog program. Limited backtracking is supported in the initial language interpreter which is written in standard Prolog. This enables alternate paths in a simulation to be explored for acceptable solutions. As in Concurrent Prolog a declarative interpretation of a program is possible. That is, a Concurrent Prolog program can be considered as a set of axioms in first order logic.
  • Thumbnail Image
    ItemOpen Access
    A distributed and parallel backtracking algorithm using virtual time
    (1987-10-01) Cleary, John; Unger, Brian W; Li, Xining
    A significant problem in Logic Programming is how to execute Prolog on multiprocessor and distributed systems. For and-parallel Prolog correctly co-ordinating backtracking across many processors is difficult. An algorithm which fully supports such backtracking is described. The algorithm is based on the Virtual Time technique first described by Jefferson and Sowizral in their Time Warp system for concurrent discrete event simulation. The algorithm preserves the standard semantics of Prolog and does not require additional program control other than directives as to where goals should be run. Because of the logical semantics of Prolog optimizations of the basic Time Warp algorithm are possible. These reduce the number of rollbacks necessary and the amount of recomputation necessary after a rollback.
  • Thumbnail Image
    ItemOpen Access
    A distributed software prototyping and simulation environment: JADE
    (1985-10-01) Unger, Brian W; Dewar, Alan; Cleary, John; Birtwistle, Graham
    Jade is an environment that supports the development of distributed software. Components may be written in any of a number of different languages. A common inter-process communication protocol provides a uniform interface among the components. A window system allows the user to interact with many different processes at once. A hierarchical graphics system is provided for use with documentation and programming, and for support of monitoring. Monitoring in Jade is also supported by an extensible mechanism which allows for multiple views of the same process. The non- determinism of distributed systems may be controlled in order to provide repeatability of executions and to aid in testing and debugging. Finally, the formal specification of inter-process events in Jade is supported by a communications protocol verifier, allowing run-time consistency checking. Together, these tools provide a powerful environment for software prototyping and simulation.
  • No Thumbnail Available
    ItemMetadata only
    Distributed software prototyping and simulation in JADE
    (1984-11-01) Lomow, Greg; Unger, Brian W
    A prototyping and simulation tool that supports the development of distributed programs is described. This tool, called Jems, forms a part of Jade, a distributed software prototyping environment. The Jade environment provides tools for the design, implementation, debugging, testing, maintenance, and performance analysis of distributed, concurrent programs. Novel features of Jade include the support of: multi-lingual distributed programs; flexible monitoring of inter-process communication; multiple views into executing programs via a window system; graphical animation of executing programs; and the prototyping of distributed software. This paper presents an overview of the Jade environment, describes the distributed software prototyping tool, and outlines the status of the project.
  • Thumbnail Image
    ItemOpen Access
    Distributed software via prototyping and simulation - JADE
    (1988-03-01) Unger, Brian W
    Jade is an environment that supports the development of distributed software. Components may be written in any of a number of different languages, with a common inter-process communication protocol providing a uniform interface among the components. A window system allows the user to interact with many different processes at once. A hierarchical graphics system is provided for use with documentation and programming, and for support of monitoring. Monitoring in Jade is also supported by an extensible mechanism which allows for multiple views of the same process. The nondeterminism of distributed systems may be controlled in order to provide repeatability of executions and to aid in testing and debugging. Finally, the formal specification of inter-process events in Jade is supported by a communications protocol verifier, allowing run-time consistency checking. Together, these tools provide a powerful environment for software prototyping and simulation. This paper is a summary of work that has been described in [Unger 85], [Lomow 85] and [Joyce 87].
  • No Thumbnail Available
    ItemMetadata only
    The flooding sink: a new approach to local area networking
    (1983-05-01) Patten, Terry; Hutchinson, Norm; Unger, Brian W
    A new local area networking technology is presented. The approach is based on an old routing algorithm called flooding - forward messages to all neighboring nodes. The problem with this algorithm is that the network is deluged with duplicate messages. The solution is a simple device which uses local memory to detect and ignore redundant messages, thus also acting as a message sink. Networks based on this device are shown to be more flexible and realiable than current networks. Flooding also has the advantage that any messages lost due to transmission errors are quickly replaced by one of the copies. This makes much of the usual low-level 'hand-shake' protocols unnecessary. When the low-level protocols are omitted, significant performance improvements are achieved. Simulation results are presented which show that this flooding technology performs better than current CSMA and ring technologies.
  • No Thumbnail Available
    ItemMetadata only
    Graphical monitoring of distributed systems
    (1984-03-01) Unger, Brian W; Joyce, Jeff
    A tool for the animation of message interactions between concurrent processes is presented. Each message interaction, such as a send or receive, has a corresponding static graphical representation. The interactions among the processes of an executing distributed computation are represented by an animated sequence of these static images. This graphical monitoring tool, called Mona, is part of a distributed software prototyping environment, called Jade. The Jade environment supports the implementation of distributed programs written in ADA, C, Lisp, Prolog, and Simula. The execution of these multilingual programs can be distributed over a loosely coupled network of Vax/Unix systems and microcomputer workstations. Preliminary experience using Mona to develop distributed programs is also reported. In particular, the application of Mona to the debugging of a distributed implementation of a workstation virtual terminal window system is described. We also discuss the advantages of graphical monitoring over more traditional approaches, i.e. textual tracing.
  • No Thumbnail Available
    ItemMetadata only
    Graphical monitoring of distributed systems
    (1984-10-01) Joyce, Jeff; Unger, Brian W
    A tool for the animation of message interactions between concurrent processes is presented. Each message interaction, such as a send or receive, has a corresponding static graphical representation. The interactions among the processes of an executing distributed computation are represented by an animated sequence of these static images. This graphical monitoring tool, called Mona, is part of a distributed software prototyping environment, called Jade. The Jade environment supports the implementation of distributed programs written in ADA, C, Lisp, Prolog, and Simula. The execution of these multi-lingual programs can be distributed over a loosely coupled network of Vax/Unix systems and microcomputer workstations. Preliminary experience using Mona to develop distributed programs is also reported. In particular, the application of Mona to the debugging of a distributed implementation of a workstation virtual terminal window system is described. We also discuss the advantages of graphical monitoring over more traditional approaches, i.e. textual tracing.
  • No Thumbnail Available
    ItemMetadata only
    Graphical tracing and debugging of simulations
    (1983-11-01) Dewar, Alan; Unger, Brian W
    A graphical approach to the tracing and debugging of simulations is presented. First, a number of desirable features for such a system are briefly outlined. An extension to the Simula class SIMULATION is then described which provides these features for the application programmer. The extension has been designed so that it is simple to use in its default state but is also highly extensible, allowing the programmer to obtain graphical traces quickly or to produce graphical traces of arbitrary complexity. Examples are given illustrating both of these facets and comparing these to a non-graphical trace of the same program. Limitations to the approach are discussed.
  • No Thumbnail Available
    ItemMetadata only
    A housing allocation algorithm for policy impact analysis
    (1976-07-01) Merlino, Gianfranco; Unger, Brian W
    An algorithm designed to simulate the behavior of households while they compete for housing is described. The algorithm accepts as inputs an existing housing state, a new household demand for dwellings and a new supply of dwellings. The acquisition of these available dwellings by the homeless households is simulated producing a new housing state, modified dwelling costs and measures of household dissatisfaction and dwelling shortages. The algorithm is defined using the Algol 60 language and preliminary parameter sensitivity results are presented.
  • Thumbnail Image
    ItemOpen Access
    The JADE approach to distributed software development
    (1985-11-01) Unger, Brian W; Dewar, Alan; Cleary, John; Birtwistle, Graham
    Jade is an environment that supports the development of distributed software. Components may be written in any of a number of different languages. A common inter-process communication protocol provides a uniform interface among the components. A window system allows the user to interact with many different processes at once and allows for multiple views of the same process. A hierarchical graphics system is provided for use with documentation and programming, and for support of monitoring. The non-determination of distributed systems may be controlled in order to provide repeatability of executions and to aid in prototyping real-time distributed software. Finally, the formal specification of inter-process events in Jade is supported by a communications protocol verifier, allowing run-time consistency checking. We describe these tools and their use in the development of distributed software for the control of a simulated system of parking lots.
  • Thumbnail Image
    ItemOpen Access
    JADE status report: a local computing network for research in distributed programming environments
    (1986-01-01) Unger, Brian W; Birtwistle, G.; Cleary, J.; Hill, D.; Keenan, T.; Rokne, J.; Kendall, J.; Vollmerhaus, W.; Witten, I.; Wyvill, B.
    No abstract
  • Thumbnail Image
    ItemOpen Access
    JADE virtual time implementation manual
    (1986-09-01) Unger, Brian W; Cleary, John; Lomow, Greg; Xining, Li; Zhonge, Xiao; Slind, Konrad
    No Abstract
  • No Thumbnail Available
    ItemMetadata only
    JADE: a distributed software prototyping environment
    (1983-04-01) Witten, Ian H.; Birtwistle, Graham M.; Cleary, John; Hill, David R.; Levinson, Danny; Lomow, Greg; Neal, Radford; Peterson, Murray; Unger, Brian W; Wyvill, Brian
    The Jade research project is aimed at building an environment which comfortably supports the design, construction, and testing of distributed computer systems. This note is an informal project description which delimits the scope of the work and identifies the research problems which are tackled. Some design issues are discussed, and progress to date is described.
  • No Thumbnail Available
    ItemMetadata only
    JADE: a simulation & software prototyping environment
    (1983-11-01) Unger, Brian W; Birtwistle, Graham; Cleary, John; Hill, David; Lomow, Greg; Neal, Radford; Peterson, Murray; Witten, Ian; Wyvill, Brian
    Jade provides an integrated set of tools which are designed to support the development of distributed software and systems. The Jade environment provides tools for the design, implementation, debugging, testing, maintenance, and performance analysis of distributed, concurrent programs. Novel features of Jade are that it is based on the modelling and simulation of target distributed systems and partially automatic program generation is supported. The goals of Jade are to provide a cost effective software development environment that is both easy and comfortable to use, and which can produce more reliable, maintainable programs. This paper presents an overview of the Jade environment, describes its major components, and outlines the status of the project.