Concurrent Pascal as a simulation language

This is a personal history of the early development of the monitor concept and its implementation in the programming language Concurrent Pascal. The paper explains how monitors evolved from the ideas of Dahl, Dijkstra, Hoare, and the author (1971-73). At Caltech the author and his students developed and implemented Concurrent Pascal and used it to write several model operating systems (1974-75). A portable implementation of Concurrent Pascal was widely distributed and used for system design (1976-90). The monitor paradigm was also disseminated in survey papers and text books. The author ends the story by expressing his own mixed feelings about monitors and Concurrent Pascal.

The programming language Concurrent Pascal can be used for the construction not only of small memory‐resident operating systems but also of moderate size swapping systems. If a few amendments are made to the kernel, it is possible to provide a virtual memory management as a part of the CPASCAL program. This approach was taken in the construction of a small time‐sharing system called MUSIC (Multi‐User System In Concurrent Pascal), the design of which is briefly sketched, along with some considerations about the language.

The SIMAN computer language is a general-purpose, discrete-continuous simulation analysis language for modeling a variety of systems. The language has been extensively used for modeling manufacturing systems but has many features that are advantageous in the modeling of mining materials handling systems. The authors have evaluated the language by applying it to an open pit truck/shovel materials handling system. This paper summarizes the results of the application of the model, compares its features with other simulation languages and evaluates its usefulness for simulation of mining systems.

The paper describes a new programming language for structured programming of computer operating systems. It extends the sequential programming language Pascal with concurrent programming tools called processes and monitors. Section I explains these concepts informally by means of pictures illustrating a hierarchical design of a simple spooling system. Section II uses the same example to introduce the language notation. The main contribution of Concurrent Pascal is to extend the monitor concept with an explicit hierarchy Of access' rights to shared data structures that can be stated in the program text and checked by a compiler.

The concept of “protection” in programming languages refers to the ability to express directly in the language the desired access control relationships for all objects defined in the language. The use of such mechanisms as data types, scope, parameter passing mechanisms, routines as parameters, abstract data types, and capabilities in Pascal, Concurrent Pascal, Euclid, Clu, and Gypsy are explored via a simple example which embodies many protection problems. The usefulness of language defined and enforced protection mechanisms to the process of formal verification is discussed.

This is a description of the single-user operating system Solo written in the programming language Concurrent Pascal. It supports the development of Sequential and Concurrent Pascal programs for the PDP 11/45 computer. Input/output are handled by concurrent processes. Pascal programs can call one another recursively and pass arbitrary parameters among themselves. This makes it possible to use Pascal as a job control language. Solo is the first major example of a hierarchical concurrent program implemented in terms of abstract data types (classes, monitors and processes) with compile-time control of most access rights. It is described here from the user’s point of view as an introduction to another paper describing its internal structure.

In discussing continuous system simulation languages in Chapter 6 it was pointed out that the only widely accepted’ standard’ which exists for continuous system simulation software is the CSSL specification published in 1967. Many important developments since that time have been based on the 1967 specification, but it is now recognized that software engineering principles, and other developments in hardware and software, provide opportunities for some entirely new concepts in simulation languages. New languages are already in use, such as ESL [1], COSMOS [21 and SYSMOD [3], which are in some respects fundamentally different from previous generations of simulation software and were developed using software engineering principles. The ESL simulation language, which was developed at the University of Salford in the UK with support from the European Space Agency (ESA), is of particular interest. It was based upon outline proposals produced at Salford in 1981 for a new CSSL specification [41. The ideas contained in that software specification did not define a complete simulation language and were intended to provoke discussion within the simulation community. The proposals by the Salford group were an outline and allowed flexibility and potential for contributions by others by leaving many points of detail unspecified. Although discussed at considerable length by the CSSL Committee of the Society for Computer Simulation (SCS), and by the Technical Committee TC3 of the International Association for Mathematics and Computers in Simulation (IMACS), no formal specification emerged. Many of the developments in simulation software which have taken place since 1981 are consistent with the ideas which were put forward in that outline specification.

A continuous system simulation language for an advanced hybrid computing system (Ahcssl)

Simulation languages develop and evolve over time, and the courses in which modeling and simulation are taught must also evolve to keep pace. In the McMaster University MBA program, a study was undertaken in order to select a new simulation language for a system modeling and simulation course in which GPSS had previously been used, in order to demonstrate a broader possible selection of possible application areas for simulation. The language which was selected was SLAM II, and this selection was confirmed by monitoring the reactions and perceptions of the students to both the old and new languages, which were taught concurrently in two separate sections.

This study developed a program to simulate a haulage system with trucks and loaders for an underground mine using the GPSS/H simulation language. The Daesung MDI limestone mine located in Korea was selected as the study area. Using the developed program and parameter values determined by a field survey, simulations of the truck-loader haulage system were performed to optimize the number of trucks dispatched at three loading points in the study area. The simulation results showed that maximum production can be expected by dispatching four, seven, and three trucks to each loading point, respectively. Because the developed program was found to properly simulate the haulage system, it could be used for practical purposes in the study area.

Complex adaptive systems (CAS) exhibit properties beyond complex systems such as self-organization, adaptability and modularity. Designing models of CAS is typically a non-trivial task as many components are made up of sub-components and rely on a large number of complex interactions. Studying features of these models also requires specific work for each system. Moreover, running these models as simulations with a large number of entities requires a large amount of processing power. We propose a language, Complex Adaptive Systems Language (CASL), and a framework to handle these issues. In particular, an extension to CASL that introduces the concept of ‘semantic grouping’ allows for large scale simulations to execute on relatively modest hardware. A component of our framework, the observation module, aims to provide an extensible and expandable set of metrics to study key features of CAS such as aggregation, adaptability, and modularity, while also allowing for more domain-specific techniques.

Currently, embedded systems make use of large, multiprocessing systems on chip integrating complex application software running on the different processors in close interaction with the application-specific hardware. These systems demand new modeling, simulation, and performance estimation tools and methodologies for system architecture evaluation and design exploration. Recently approved as IEEE 1666 standard, SystemC has proven to be a powerful language for system modeling and simulation. In this chapter, SCoPE, a SystemC framework for platform modeling, SW source-code behavioral simulation and performance estimation of embedded systems is presented. Using SCoPE, the application SW running on the different processors of the platform can be simulated efficiently in close interaction with the rest of the platform components. In this way, fast and sufficiently accurate performance metrics are obtained for design-space exploration.

Design Space Exploration for complex, multi-processor embedded Systems demands new modeling, simulation, performance estimation tools and design methodologies. Recently approved as IEEE 1666 standard, SystemC has proven to be a powerful language for system modeling and simulation. This chapter presents M3-SCoPE: a SystemC framework for platform modeling, SW source-code behavioral simulation and performance estimation of multi-processor embedded systems. Using M3-SCoPE, the application SW running on the different processors of the platform can be simulated efficiently in close interaction with the rest of the platform components. In this way, fast and sufficiently accurate performancemetrics of the system are obtained. These metrics are then delivered to the Design Space Exploration (DSE) tools to evaluate the quality of the different configuration in order to select the best ones.

We present an enumerative program synthesis framework called component-based refactoring that can refactor “direct” style code that does not use library components into equivalent “combinator” style code that does use library components. This framework introduces a sound but incomplete technique to check the equivalence of direct code and combinator code called equivalence by canonicalization that does not rely on input-output examples or logical specifications. Moreover, our approach can repurpose existing compiler optimizations, leveraging decades of research from the programming languages community. We instantiated our new synthesis framework in two contexts: (i) higher-order functional combinators such as map and filter in the staticallytyped functional programming language Elm and (ii) high-performance numerical computing combinators provided by the NumPy library for Python. We implemented both instantiations in a tool called Cobbler and evaluated it on thousands of real programs to test the performance of the component-based refactoring framework in terms of execution time and output quality. Our work offers evidence that synthesis-backed refactoring can apply across a range of domains without specification beyond the input program.

The important features of several software packages for communication system simulation are discussed. Whereas initial versions of SYSTID and similar packages are language-oriented and designed to operate in a batch mode, such packages as ICS, ICSSM, etc. are interactive and menu driven. The packages developed in recent years (BOSS, MODEM, LabVIEW, etc.) involve powerful workstation and personal computers with friendly computing environments and highly visual and graphical user interfaces. A number of issues arise when simulation is selected as a design or analysis tool. Important considerations are the simulation environment, computer accessibility and cost, simulation accuracy, processing speed, and capability of the simulation language. It is noted that a visual programming tool like LabView gives a very favorable response to these considerations. Although LabView cannot replace the simulation languages such as SYSTID or ICS in terms of speed, it can be a helpful tool for communication system designers an analysts. >