Concurrency has been expressed variously in terms of formal languages (typically via the shuffle operator), partial orders, and temporal logic, inter alia. In this paper we extract from these three approaches a single hybrid approach having a rich language that mixes algebra and logic and having a natural class of models of concurrent processes. The heart of the approach is a notion of partial string derived from the view of a string as a linearly ordered multiset by relaxing the linearity constraint, thereby permitting partially ordered multisets or pomsets. Just as sets of strings form languages, so do sets of pomsets form processes. We introduce a number of operations useful for specifying concurrent processes and demonstrate their utility on some basic examples. Although none of the operations is particularly oriented to nets it is nevertheless possible to use them to express processes constructed as a net of subprocesses, and more generally as a system consisting of components. Th...

An important goal in software engineering is to describe complex software systems at an architectural level of abstraction. While there are many useful architectural paradigms (pipes, blackboards, etc.) they are typically understood only idiomatically and applied in an ad hoc fashion. We show how a formal model allows us to say precisely what we mean by a software architecture, explore its properties, and systematically describe instances of the architecture. We illustrate the approach using the well-known example of pipe-filter architectures. This research was sponsored by the National Science Foundation under Grants CCR-9109469 and CCR-9112880, and by Siemens Corporate Research, Inc. The views and conclusions contained in this document are those of the author and should not be interpreted as representing the official policies, either expressed or implied, of Siemens or the U.S. Government. Keywords: Dataflow Systems, Pipes and Filters, Software Architecture, Software Engineering, S...

Abstract — The sheer complexity of today’s embedded systems forces designers to start with modeling and simulating system components and their interactions in the very early design stages. It is therefore imperative to have good tools for exploring a wide range of design choices, especially during the early design stages where the design space is at its largest. This article presents an overview of the Sesame framework which provides high-level modeling and simulation methods and tools for system-level performance evaluation and exploration of heterogeneous embedded systems. More specifically, we describe Sesame’s modeling methodology and trajectory. It takes a designer systematically along the path from selecting candidate architectures, using analytical modeling and multi-objective optimization, to simulating these candidate architectures with our system-level simulation environment. This simulation environment subsequently allows for architectural exploration at different levels of abstraction while maintaining high-level and architectureindependent application specifications. We illustrate all these aspects using a case study in which we traverse Sesame’s exploration trajectory for a Motion-JPEG encoder application.

We describe the SVP data model. The goal of SVP is to model both set and stream data, and to model parallelism in bulk data processing. SVP also shows promise for other parallel processing applications. SVP models collections, which include sets and streams as special cases. Collections are represented as ordered tree structures, and divide-and-conquer mappings are easily defined on these structures. We show that many useful database mappings (queries) have a divide-and-conquer format when specified using collections, and that this specification exposes parallelism. We formalize a class of divide-and-conquer mappings on collections called SVP-transducers. SVP-transducers generalize aggregates, set mappings, stream transductions, and scan computations. At the same time, they have a rigorous semantics based on continuity with respect to collection orderings, and permit implicit specification of both independent and pipeline parallelism. 1 Introduction Achieving parallelism in bulk data...

Current message-passing parallel computers provide send and receive primitives with a wide variety of blocking, synchronization, selectivity and ordering properties. Unfortunately, the interactions between the different properties of the send and receive primitives can be extremely complex, and as a result, the precise semantics of these primitives are not well understood. In this paper we present formal models for message-passing systems that provide both synchronous and asynchronous sends, both blocking and nonblocking sends and receives, and a variety of ordering properties. In addition, the receive primitives are very general in that they can specify the desired source and/or tag value of a message. Our models apply to all message-passing programs, including ones with errors, and they apply to parallel computers with arbitrary amounts of buffering. To the best of our knowledge, this is the first time that such rich message-passing models have been defined formally. In addition to p...

Concurrent programming enjoys a proliferation of languages but suffers from the lack of a general method of language comparison. In particular, concurrent (as well as sequential) programming languages can-not be usefully distinguished based on complexity-theoretic considerations, since most of them are Turing-complete. Nevertheless, differences between program-ming languages matter, else we would not have invented so many of them. We develop a general method for comparing concur-rent programming languages based on their algebraic (structural) complexity, and, using this method, achieve separation results among many well-known concurrent languages. The method is not restricted to concurrent languages. It can be used to compare the algebraic complexity of abstract machine models, other families of programming languages, logics, and, more generaly, any family of lan-guages with some syntactic operations and a notion of semantic equivalence. The method can also be used to compare the algebraic complexity of families of opera-tions wit hin a language or across languages. We note that using the method we were able to compare lan-guages and computational models that do not have a common semantic basis.

this paper we supplement the taxonomy list above with another kind of semantical domains, namely we consider connected relations. In the most general setting connected relations are parametrized by a given domain D which obeys some specific finiteness conditions; we say that D is an F-domain [RT3]. In the particular case when D is the domain of natural numbers, connected relations appeared first in [Maz1] under the name of multitrees. For connected relations one can define a natural version of synchronization (strong conjunction).

Abstract. Embedded system design in general can only be successful if it is based on a suitable Model of Computation (MoC) that can be well represented in an executable System-level Description Language (SLDL) and is supported by a matching set of design tools. While C-based SLDLs, such as SystemC and SpecC, are popular in system-level modeling and validation, current tool flows impose serious restrictions on the synthesizable subset of the supported SLDL. A properly aligned and clean system-level MoC is often neglected or even ignored. In this paper, we motivate the need for a well-defined MoC in embedded system models they can represent, in contrast to the smaller set of models the tools can support. Based on these findings, we then outline a new approach, called ConcurrenC, that defines a true system level of abstraction, aptly fits system modeling requirements, and can be expressed precisely in both SystemC and SpecC. Using the case study of a H.264 video decoder, we demonstrate how the ConcurrenC approach meets the needs and characteristics of a industry size embedded application. 1

This paper presents a model for a network of communicating processes. We extend well known ideas in sequentia] programming such as procedures, parameter passing and binding, and recursion to distributed programs. We stress the notion of implementation-hiding, i.e. the invoker of a process or procedure has no knowledge of the implementation of the invoked computation. I.

......Designers of digital circuitry for real-time processing of video data in consumer electronics applications face the conflicting requirements of high computational capability and low hardware cost. To address these requirements, many commercial chips for consumer video processing use fixed-function logic designed to perform a set of specific tasks (for example, video decoding, scaling, and noise reduction). However, several factors motivate the development of a more flexible approach: Some applications must support many video-coding standards, including some that are in a state of flux.