Downloads & Free Reading Options - Results

Computational models are arising in which programs are constructed by specifying large networks of very simple computational devices. Although such models can potentially make us of a massive amount of concurrency, their usefulness as a programming model for the design of complex systems will ultimately be decided by the design of complex systems will ultimately be decided by the ease in which such networks can be programmed (constructed). This thesis outlines a language for specifying computational networks. The language (AFL-1) consists of a set of primitives, and a mechanism to group these elements into higher levels structures. An implementation of this language runs on the Thinking Machines Corporation, Connection Machine. Two significant examples were programmed in the language, an expert system (CIS), and a planning system (AFPLAN). These systems are explained and analyzed in terms of how they compare with similar systems written in conventional languages.

Concurrent logic languages are high-level programming languages for parallel and distributed systems that offer a wide range of both known novel concurrent programming techniques. Being logic programming languages, they preserve many advantages of the abstract logic programming model, including the logical reading of programs and computations, the convenience of representing data-structures with logical terms and manipulating them using unification, and the amenability to meta-programming. Operationally, their model of computation consists of a dynamic set of concurrent processes, communicating by instantiating shared logical variables, synchronizing by waiting for variables to be instantiated, and making the nondeterministic choices, possibly based on the availability of values of variables. This paper surveys the family of concurrent logic programming languages within a uniform operational framework. It demonstrates the expressive power of even the simplest language in the family, and investigates how varying the basic synchronization and control constructs affect the expressiveness and efficiency of the resulting languages. In addition, the paper reports on techniques for sequential and parallel implementations of languages in this family, mentions their applications to date, and relates these languages to the abstract logic programming model, to the programming language Prolog, and to other concurrent computational models and programming languages. (KR)

This curriculum module is concerned with support for concurrent programming provided to the application programmer by operating systems and programming languages. This includes system calls and language constructs for process creation, termination, synchronization, and communication, as well as nondeterministic language constructs such as the selective wait and timed call. Several readily available languages are discussed and compared: concurrent programming using system services of the UNIX operating system is introduced for the sake of comparison and contrast.

Concurrency of activities has long been recognized as an important feature in many computer systems. These systems allow concurrent operations for a number of reasons on which three are particularly common. First, by executing several jobs, simultaneously, multiprogramming and time-sharing systems can make fuller use of the computing resources. Second, real-time transaction systems, such as airline reservation and point-of-sale terminal systems, allow a number of users to access a single database concurrently and to obtain responses in real-time. Finally, high speed parallel computers, such as array processors dedicate a number of processors to the execution of a single program to speed up completion of a computation. (Author)

A concurrent program is one defining actions that may be performed simultaneously. This module discusses the nature of such programs and provides an overview of the means by which they may be constructed and executed. Emphasis is given to the terminology used in this field and the underlying concepts involved. This module is largely concerned with explicit concurrency, where concurrent behavior is specified by the program designer. Particular attention is paid to programs that can be considered inherently concurrent, that is, programs that are constructed to control or model physical systems that involve parallel activity. The module also includes a brief introduction to performance- oriented concurrency, where concurrency is used to improve program performance by taking advantage of hardware support for parallel processing. The module is divided into three sections. The first deals with basic concepts in concurrent programming, covering characteristic attributes, formal properties, standard design problems, and execution details. The second section discusses the steps in constructing concurrent programs for specification to coding. The final section briefly examines concurrency from the point of view of some common application areas. The module gives a foundation for a deeper study of specific topics in concurrent programming. It also provides the preparatory material for a study of the concurrent aspects of application areas such as real-time (embedded) systems, database systems, operating systems, and many simulation systems.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

Concurrent programming in Python may be hard. A lot of solutions exists though. Most of them are based on an eventloop. This talk will present what I discovered and tested along the time with code examples, from asyncore to asyncio, passing by gevent, eventlet, twisted and some new alternatives like evergreen or gruvi. It will also present my little experiment in porting the Go concurrency model in Python named [offset](http://github.com/benoitc/offset), how it progressed in 1 year and how it became a fully usable library . This presentation will be an update of the presentation I gave at the FOSDEM 2014. It will introduce to the concurrency concepts and how they are implemented in the different libraries.

This document proposes a unifying theory for the development of programs for a variety of architectures and applications. The computational model is unbounded nondeterministic iterative transformations of the program state. Transformations of the program state are represented by multiple assignments. The theory attempts to decouple the programmer's thinking about a program and its implementation on an architecture; we attempt to separate the concerns of what from those of where, when, and how. Details about implementations are considered in mappings of programs to architectures. We hope to demonstrate that we can develop, specify and refine solution strategies independent of architectures. The utility of a new approach is suspect, especially when it is a radical departure from the conventional. Therefore, we have made a conscientious effort to apply our ideas to a number of architectures and application domains. Our experience is encouraging. Keywords: Parallel programming; Unity computer programs.

This document proposes a unifying theory for the development of programs for a variety of architectures and applications. The computational model is unbounded nondeterministic iterative transformations of the program state. Transformations of the program state are represented by multiple assignments. The theory attempts to decouple the programmer's thinking about a program and its implementation on an architecture; we attempt to separate the concerns of what from those of where, when, and how. Details about implementations are considered in mappings of programs to architectures. We hope to demonstrate that we can develop, specify and refine solution strategies independent of architectures. The utility of a new approach is suspect, especially when it is a radical departure from the conventional. Therefore, we have made a conscientious effort to apply our ideas to a number of architectures and application domains. Our experience is encouraging. Keywords: Parallel programming; Unity computer programs.

This document proposes a unifying theory for the development of programs for a variety of architectures and applications. The computational model is unbounded nondeterministic iterative transformations of the program state. Transformations of the program state are represented by multiple assignments. The theory attempts to decouple the programmer's thinking about a program and its implementation on an architecture; we attempt to separate the concerns of what from those of where, when, and how. Details about implementations are considered in mappings of programs to architectures. We hope to demonstrate that we can develop, specify and refine solution strategies independent of architectures. The utility of a new approach is suspect, especially when it is a radical departure from the conventional. Therefore, we have made a conscientious effort to apply our ideas to a number of architectures and application domains. Our experience is encouraging. Keywords: Parallel programming; Unity computer programs.

A simple but complete set of algebraic laws is given for a basic language (e.g., at the level of boogie). They include the algebraic properties of concurrency, similar to those of sequential composition. The laws are valid equally for interleaved concurrency and separated concurrency, and mixtures between them (e.g., as used in VCC). Most recognised methods of program analysis and verification are simply derived from the algebra. But will it be useful? ©2011 Microsoft Corporation. All rights reserved.

This paper summarizes the first twenty years of concurrent programming and identifies the major development phases as an initial hardware challenge followed by a software crisis, a conceptual innovation, and language development which in turn led to formal understanding and hardware refinement. The paper draws a parallel between this development and the present challenge of distributed computing. (Author)

The first example is an implementation in each of four languages (Ada, Concurrent C, Co-Pascal, and occam) of the famous Dining Philosophers problem first stated by Dijkstra. In this metaphorical statement of deadlock and resource allocation problems, five philosophers sit around a circular table, in the center of which is a infinitely large bowl of Chinese food. To the left and right of each philosopher is a single chopstick; each philosopher must try to acquire both chopsticks, each for awhile, then put down the chopsticks and think for awhile; this cycle repeats for some total number of meals. (Dijkstra's original formulation used spaghetti and forks; we prefer the chopstick setting because most people can eat spaghetti with one fork.) The algorithm for chopstick selection must be chosen carefully, otherwise if all philosophers grab, say, their left chopsticks and refuse to yield them, all will starve! The second example is one we have used with repeated success at The George Washington University, namely a sort race in which the three different sorting methods are activated as processes. Each sort displays its progress in its window (usually a single row) on the terminal; mutual exclusion is necessary to protect the screen, which is a writable shared resource. We have found this example interesting and fun-there is a lot of screen activity, the problem being solved is obvious, and the three independent sorts serve as placeholders for any three independent applications contending for the processor and a shared data structure. (kr)

The first example is an implementation in each of four languages (Ada, Concurrent C, Co-Pascal, and occam) of the famous Dining Philosophers problem first stated by Dijkstra. In this metaphorical statement of deadlock and resource allocation problems, five philosophers sit around a circular table, in the center of which is a infinitely large bowl of Chinese food. To the left and right of each philosopher is a single chopstick; each philosopher must try to acquire both chopsticks, each for awhile, then put down the chopsticks and think for awhile; this cycle repeats for some total number of meals. (Dijkstra's original formulation used spaghetti and forks; we prefer the chopstick setting because most people can eat spaghetti with one fork.) The algorithm for chopstick selection must be chosen carefully, otherwise if all philosophers grab, say, their left chopsticks and refuse to yield them, all will starve! The second example is one we have used with repeated success at The George Washington University, namely a sort race in which the three different sorting methods are activated as processes. Each sort displays its progress in its window (usually a single row) on the terminal; mutual exclusion is necessary to protect the screen, which is a writable shared resource. We have found this example interesting and fun-there is a lot of screen activity, the problem being solved is obvious, and the three independent sorts serve as placeholders for any three independent applications contending for the processor and a shared data structure. (kr)

This grant supported Anna Patterson from June 1994 to October 1996, Russ Allbery from October 1995 to March 1997, and Larry Yogman from January 1997 to June 1997. Patterson wrote (1) A new semantics for constructible falsity, presented at ASL Summer Meeting 96, appearing in the Bulletin of Symbolic Logic and submitted to JSL; (2) Bisimulation and Propositional Intuitionistic Logic, presented at ESSLLI'96 and in more detail at Concur 1997 in Warsaw; and (3) (with T. Costello) Guilt-Free Exponentials, to be submitted. In addition she wrote the early stages of her thesis. Allbery implemented a much faster version of Vineet Gupta's Chu space calculator. The one difficult operation is tensor product, which is known to be NP-complete and therefore requires good heuristics in order to be useful in practice. The bulk of the effort went into tuning for this operation. Yogman reimplemented the Gupta-Allbery calculator as a Java applet. This allows the user of a Java-enabled web browser, from anywhere in the world, to download and start up the calculator with one click. This version is not as fast as Allbery's and therefore not as useful for testing hypotheses about large Chu spaces. However, as a pedagogical tool for studying Chu spaces it is excellent.

Proposed at a time when the community was primarily concerned with statically structured problems in scientific computing, the Scalable Concurrent Programming Project was motivated by the following general perceptions: (1) For much of this century, scientific computing has been dominated by large regular problems and their associated computational techniques. This has been a direct result of relatively poor uniprocessor performance, simplistic software tools, and the associated education from previous generations; (2) Device technology is rapidly approaching the physical limits of CMOS technology. During the next decade vast improvements in uniprocessor performance will be increasingly difficult and expensive to obtain. Concurrency is the door to the future; Scalability is the key; and (3) As performance improves, we will not solve the same problems faster, but rather we will solve completely new and more realistic computational problems. These irregular problems will combine computations in structures, materials, fluids, and electromagnetics. They will be three-dimensional in nature, involve complex moving boundaries, and resolve transient effects. They will become the cornerstone of design, test, and manufacturing in a broad range of industries currently dominated by empiricism.

Proposed at a time when the community was primarily concerned with statically structured problems in scientific computing, the Scalable Concurrent Programming Project was motivated by the following general perceptions: (1) For much of this century, scientific computing has been dominated by large regular problems and their associated computational techniques. This has been a direct result of relatively poor uniprocessor performance, simplistic software tools, and the associated education from previous generations; (2) Device technology is rapidly approaching the physical limits of CMOS technology. During the next decade vast improvements in uniprocessor performance will be increasingly difficult and expensive to obtain. Concurrency is the door to the future; Scalability is the key; and (3) As performance improves, we will not solve the same problems faster, but rather we will solve completely new and more realistic computational problems. These irregular problems will combine computations in structures, materials, fluids, and electromagnetics. They will be three-dimensional in nature, involve complex moving boundaries, and resolve transient effects. They will become the cornerstone of design, test, and manufacturing in a broad range of industries currently dominated by empiricism.

Proposed at a time when the community was primarily concerned with statically structured problems in scientific computing, the Scalable Concurrent Programming Project was motivated by the following general perceptions: (1) For much of this century, scientific computing has been dominated by large regular problems and their associated computational techniques. This has been a direct result of relatively poor uniprocessor performance, simplistic software tools, and the associated education from previous generations; (2) Device technology is rapidly approaching the physical limits of CMOS technology. During the next decade vast improvements in uniprocessor performance will be increasingly difficult and expensive to obtain. Concurrency is the door to the future; Scalability is the key; and (3) As performance improves, we will not solve the same problems faster, but rather we will solve completely new and more realistic computational problems. These irregular problems will combine computations in structures, materials, fluids, and electromagnetics. They will be three-dimensional in nature, involve complex moving boundaries, and resolve transient effects. They will become the cornerstone of design, test, and manufacturing in a broad range of industries currently dominated by empiricism.

Experiments were conducted at NASA Ames Research Center to define multi-tasking software requirements for multiple-instruction, multiple-data stream (MIMD) computer architectures. The focus was on specifying solutions for algorithms in the field of computational fluid dynamics (CFD). The program objectives were to allow researchers to produce usable parallel application software as soon as possible after acquiring MIMD computer equipment, to provide researchers with an easy-to-learn and easy-to-use parallel software language which could be implemented on several different MIMD machines, and to enable researchers to list preferred design specifications for future MIMD computer architectures. Analysis of CFD algorithms indicated that extensions of an existing programming language, adaptable to new computer architectures, provided the best solution to meeting program objectives. The CoFORTRAN Language was written in response to these objectives and to provide researchers a means to experiment with parallel software solutions to CFD algorithms on machines with parallel architectures.

Experiments were conducted at NASA Ames Research Center to define multi-tasking software requirements for multiple-instruction, multiple-data stream (MIMD) computer architectures. The focus was on specifying solutions for algorithms in the field of computational fluid dynamics (CFD). The program objectives were to allow researchers to produce usable parallel application software as soon as possible after acquiring MIMD computer equipment, to provide researchers with an easy-to-learn and easy-to-use parallel software language which could be implemented on several different MIMD machines, and to enable researchers to list preferred design specifications for future MIMD computer architectures. Analysis of CFD algorithms indicated that extensions of an existing programming language, adaptable to new computer architectures, provided the best solution to meeting program objectives. The CoFORTRAN Language was written in response to these objectives and to provide researchers a means to experiment with parallel software solutions to CFD algorithms on machines with parallel architectures.

We present a concurrent framework for Win32 programming based on Concurrent ML, a concurrent language with higher-order functions, static typing, lightweight threads and synchronous communication channels. The key points of the framework are the move from an event loop model to a threaded model for the processing of window messages, and the decoupling of controls notifications from the system messages. This last point allows us to derive a general way of writing controls that leads to easy composition, and can accommodate ActiveX Controls in a transparent way.

We present a concurrent framework for Win32 programming based on Concurrent ML, a concurrent language with higher-order functions, static typing, lightweight threads and synchronous communication channels. The key points of the framework are the move from an event loop model to a threaded model for the processing of window messages, and the decoupling of controls notifications from the system messages. This last point allows us to derive a general way of writing controls that leads to easy composition, and can accommodate ActiveX Controls in a transparent way.

The digital logic simulator, LOGSIM248, a re-engineered version of LOGSIM, version 5.5, has been implemented as a component of the digital design environment, IDIET (Integrated Digital Engineering Tool). This new design expands the capabilities of the older version by improving run time performance, maintainability, and compatability. Written in the C programming language, LOGSIM248 boasts looser coupling between functional modules while exhibiting greater functional cohesion within these modules. As an integral part of IDIET, the simulator overcomes difficulties created by the complicated user interface of earlier versions. With greater run time performance as a goal, this new simulator was studied and adapted to produce a concurrent implementation. Here, several roadblocks were encountered which essentially showed this algorithm and data structure implementation to be difficult to parallelize at best.

[EuroPython 2014] Benoit Chesneau - Concurrent programming with Python and my little experiment [EuroPython 2014] [25 July 2014] Concurrent programming in Python may be hard. A lot of solutions exists though. Most of them are based on an eventloop. This talk will present what I discovered and tested along the time and my little experiment in porting the Go concurrency model in Python. ----- Concurrent programming in Python may be hard. A lot of solutions exists though. Most of them are based on an eventloop. This talk will present what I discovered and tested along the time with code examples, from asyncore to asyncio, passing by gevent, eventlet, twisted and some new alternatives like evergreen or gruvi. It will also present my little experiment in porting the Go concurrency model in Python named [offset](http://github.com/benoitc/offset), how it progressed in 1 year and how it became a fully usable library . This presentation will be an update of the presentation I gave at the FOSDEM 2014. It will introduce to the concurrency concepts and how they are implemented in the different libraries.

[EuroPython 2014] Benoit Chesneau - Concurrent programming with Python and my little experiment [EuroPython 2014] [25 July 2014] Concurrent programming in Python may be hard. A lot of solutions exists though. Most of them are based on an eventloop. This talk will present what I discovered and tested along the time and my little experiment in porting the Go concurrency model in Python. ----- Concurrent programming in Python may be hard. A lot of solutions exists though. Most of them are based on an eventloop. This talk will present what I discovered and tested along the time with code examples, from asyncore to asyncio, passing by gevent, eventlet, twisted and some new alternatives like evergreen or gruvi. It will also present my little experiment in porting the Go concurrency model in Python named [offset](http://github.com/benoitc/offset), how it progressed in 1 year and how it became a fully usable library . This presentation will be an update of the presentation I gave at the FOSDEM 2014. It will introduce to the concurrency concepts and how they are implemented in the different libraries.

Concurrency has been rapidly gaining importance in general-purpose computing, caused by the recent turn towards multicore processing architectures. As a result, an increasing number of developers have to learn to write concurrent programs, a task that is known to be hard even for the expert. Language designers are therefore working on languages that promise to make concurrent programming "easier" than using traditional thread libraries. However, the claim that a new language is more usable than another cannot be supported by purely theoretical considerations, but calls for empirical studies. In this paper, we present the design of a study to compare concurrent programming languages with respect to comprehending and debugging existing programs and writing correct new programs. A critical challenge for such a study is avoiding the bias that might be introduced during the training phase and when interpreting participants' solutions. We address these issues by the use of self-study material and an evaluation scheme that exposes any subjective decisions of the corrector, or eliminates them altogether. We apply our design to a comparison of two object-oriented languages for concurrency, multithreaded Java and SCOOP (Simple Concurrent Object-Oriented Programming), in an academic setting. We obtain results in favor of SCOOP even though the study participants had previous training in Java Threads.

The prime contribution of this dissertation is the creation of a programming style and environment that allows the human designers to develop an implementation independent, very high level functional view of concurrent systems. The translation of this view into a concurrently operating system is performed automatically. There is an emphasis on the human engineering aspects of the designer - computer interactions. The designers specify the problem through declaring variable structures and composing equations which relate the variables. The designers of a concurrent system interact with automatic systems on two levels: On the global level, the Configurator accepts as input a graph of the network of subsystems, modules and files. It verifies the validity of interfaces and implements the network by generating command language programs that set up communications and optimize parallelism among modules. The modules are executed under multiprogramming time sharing operating systems in respective sequential processors in a network. On the local level, the MODEL Compiler accepts as input an individual module specification. It performs checking of completeness and consistency of variables and equations and generates an optimized sequential program in a high level language (PL/I). Originator-supplied key words include: Configurations, Computer files.

The prime contribution of this dissertation is the creation of a programming style and environment that allows the human designers to develop an implementation independent, very high level functional view of concurrent systems. The translation of this view into a concurrently operating system is performed automatically. There is an emphasis on the human engineering aspects of the designer - computer interactions. The designers specify the problem through declaring variable structures and composing equations which relate the variables. The designers of a concurrent system interact with automatic systems on two levels: On the global level, the Configurator accepts as input a graph of the network of subsystems, modules and files. It verifies the validity of interfaces and implements the network by generating command language programs that set up communications and optimize parallelism among modules. The modules are executed under multiprogramming time sharing operating systems in respective sequential processors in a network. On the local level, the MODEL Compiler accepts as input an individual module specification. It performs checking of completeness and consistency of variables and equations and generates an optimized sequential program in a high level language (PL/I). Originator-supplied key words include: Configurations, Computer files.

ADA150771

The \"von Neumann bottleneck\" imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignment statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and also allow is to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative \"library\" programs into functional ones which are well suited to concurrent processing.

There is often a sort of a protocol associated to each class, stating when and how certain methods should be called. Given that this protocol is, if at all, described in the documentation accompanying the class, current mainstream object-oriented languages cannot provide for the verification of client code adherence against the sought class behaviour. We have defined a class-based concurrent object-oriented language that formalises such protocols in the form of usage types. Usage types are attached to class definitions, allowing for the specification of (1) the available methods, (2) the tests clients must perform on the result of methods, and (3) the object status - linear or shared - all of which depend on the object's state. Our work extends the recent approach on modular session types by eliminating channel operations, and defining the method call as the single communication primitive in both sequential and concurrent settings. In contrast to previous works, we define a single category for objects, instead of distinct categories for linear and for shared objects, and let linear objects evolve into shared ones. We introduce a standard sync qualifier to prevent thread interference in certain operations on shared objects. We formalise the language syntax, the operational semantics, and a type system that enforces by static typing that methods are called only when available, and by a single client if so specified in the usage type. We illustrate the language via a complete example.

In this talk, I present a new programming language designed for structured concurrency. The language is based on components which are organized in hierarchical and “pointer-free” structures. The components run concurrently and only interact via communication. With this model, hierarchical encapsulation, statefull interactions, race-free concurrency, flexible polymorphism and a simple memory management is enabled. The language is implemented by a native runtime system which allows the efficient execution of a huge number of light-weight processes. In a case study of traffic simulation, it has been demonstrated that the new language enables a more natural mapping to the program and also offers a higher performance compared to other sequential or con¬current simulations. ©2008 Microsoft Corporation. All rights reserved.

We have designed a new logic programming language called LM (Linear Meld) for programming graph-based algorithms in a declarative fashion. Our language is based on linear logic, an expressive logical system where logical facts can be consumed. Because LM integrates both classical and linear logic, LM tends to be more expressive than other logic programming languages. LM programs are naturally concurrent because facts are partitioned by nodes of a graph data structure. Computation is performed at the node level while communication happens between connected nodes. In this paper, we present the syntax and operational semantics of our language and illustrate its use through a number of examples.

Includes bibliographical references (pages 229-237) and index

Writing concurrent applications is extremely challenging, not only in terms of producing bug-free and maintainable software, but also for enabling developer productivity. In this article we present the AEminium concurrent-by-default programming language. Using AEminium programmers express data dependencies rather than control flow between instructions. Dependencies are expressed using permissions, which are used by the type system to automatically parallelize the application. The AEminium approach provides a modular and composable mechanism for writing concurrent applications, preventing data races in a provable way. This allows programmers to shift their attention from low-level, error-prone reasoning about thread interleaving and synchronization to focus on the core functionality of their applications. We study the semantics of AEminium through microminium, a sound core calculus that leverages permission flow to enable concurrent-by-default execution. After discussing our prototype implementation we present several case studies of our system. Our case studies show up to 6.5X speedup on an eightcore machine when leveraging data group permissions to manage access to shared state, and more than 70% higher throughput in a Web server application.

Writing concurrent applications is extremely challenging, not only in terms of producing bug-free and maintainable software, but also for enabling developer productivity. In this article we present the AEminium concurrent-by-default programming language. Using AEminium programmers express data dependencies rather than control flow between instructions. Dependencies are expressed using permissions, which are used by the type system to automatically parallelize the application. The AEminium approach provides a modular and composable mechanism for writing concurrent applications, preventing data races in a provable way. This allows programmers to shift their attention from low-level, error-prone reasoning about thread interleaving and synchronization to focus on the core functionality of their applications. We study the semantics of AEminium through microminium, a sound core calculus that leverages permission flow to enable concurrent-by-default execution. After discussing our prototype implementation we present several case studies of our system. Our case studies show up to 6.5X speedup on an eightcore machine when leveraging data group permissions to manage access to shared state, and more than 70% higher throughput in a Web server application.

The von Neumann bottleneck imposes severe limitations on programming languages. This thesis points out that although the hardware limitations imposed by this bottleneck are being overcome, its constraints will remain in programs as long as there are assignments statements in their code. We assert that functional programming languages allow us to harness the processing power of computers with hundreds or even thousands of processors, and which allow us to solve problems which are time/cost prohibitive on a uniprocessor. We discuss a mechanical method for transforming imperative programs into functional programs. We feel that the mechanical transformation process is very inexpensive, and that it might be the best way to make imperative library programs into functional ones which are well suited to concurrent processing. Originator supplied key words include: Parallel processing, Functional, Concurrent processing, and Multiprocessor.

Programming concurrent systems is notoriously subtle and error-prone. This is hardly surprising considering that mainstream memory models, which form the basis of concurrent languages' semantics, are confusing and provide only weak memory-ordering guarantees. We tolerate such weak memory models in order to facilitate efficient compiler and hardware implementations. I will present a novel, holistic approach that gives strong memory model guarantees without sacrificing performance. I will first discuss DRFx, a memory model which relies on cooperation between the compiler and the hardware to provide straightforward guarantees to the programmer while still permitting most common optimizations. This is achieved through an extremely lightweight form of dynamic data race detection and the introduction of a memory model exception. I will also present more recent research which suggests that an efficient implementation of end-to-end sequential consistency (a strong, intuitive memory model) may be within reach. ©2011 Microsoft Corporation. All rights reserved.

Programming concurrent systems is notoriously subtle and error-prone. This is hardly surprising considering that mainstream memory models, which form the basis of concurrent languages' semantics, are confusing and provide only weak memory-ordering guarantees. We tolerate such weak memory models in order to facilitate efficient compiler and hardware implementations. I will present a novel, holistic approach that gives strong memory model guarantees without sacrificing performance. I will first discuss DRFx, a memory model which relies on cooperation between the compiler and the hardware to provide straightforward guarantees to the programmer while still permitting most common optimizations. This is achieved through an extremely lightweight form of dynamic data race detection and the introduction of a memory model exception. I will also present more recent research which suggests that an efficient implementation of end-to-end sequential consistency (a strong, intuitive memory model) may be within reach. ©2011 Microsoft Corporation. All rights reserved.

Programming concurrent systems is notoriously subtle and error-prone. This is hardly surprising considering that mainstream memory models, which form the basis of concurrent languages' semantics, are confusing and provide only weak memory-ordering guarantees. We tolerate such weak memory models in order to facilitate efficient compiler and hardware implementations. I will present a novel, holistic approach that gives strong memory model guarantees without sacrificing performance. I will first discuss DRFx, a memory model which relies on cooperation between the compiler and the hardware to provide straightforward guarantees to the programmer while still permitting most common optimizations. This is achieved through an extremely lightweight form of dynamic data race detection and the introduction of a memory model exception. I will also present more recent research which suggests that an efficient implementation of end-to-end sequential consistency (a strong, intuitive memory model) may be within reach. ©2011 Microsoft Corporation. All rights reserved.

A verification method for distributed systems based on decoupling forward and backward behaviour is proposed. This method uses an event structure based algorithm that, given a CCS process, constructs its causal compression relative to a choice of observable actions. Verifying the original process equipped with distributed backtracking on non-observable actions, is equivalent to verifying its relative compression which in general is much smaller. We call this method Declarative Concurrent Programming (DCP). DCP technique compares well with direct bisimulation based methods. Benchmarks for the classic dining philosophers problem show that causal compression is rather efficient both time- and space-wise. State of the art verification tools can successfully handle more than 15 agents, whereas they can handle no more than 5 following the traditional direct method; an altogether spectacular improvement, since in this example the specification size is exponential in the number of agents.

A verification method for distributed systems based on decoupling forward and backward behaviour is proposed. This method uses an event structure based algorithm that, given a CCS process, constructs its causal compression relative to a choice of observable actions. Verifying the original process equipped with distributed backtracking on non-observable actions, is equivalent to verifying its relative compression which in general is much smaller. We call this method Declarative Concurrent Programming (DCP). DCP technique compares well with direct bisimulation based methods. Benchmarks for the classic dining philosophers problem show that causal compression is rather efficient both time- and space-wise. State of the art verification tools can successfully handle more than 15 agents, whereas they can handle no more than 5 following the traditional direct method; an altogether spectacular improvement, since in this example the specification size is exponential in the number of agents.

A verification method for distributed systems based on decoupling forward and backward behaviour is proposed. This method uses an event structure based algorithm that, given a CCS process, constructs its causal compression relative to a choice of observable actions. Verifying the original process equipped with distributed backtracking on non-observable actions, is equivalent to verifying its relative compression which in general is much smaller. We call this method Declarative Concurrent Programming (DCP). DCP technique compares well with direct bisimulation based methods. Benchmarks for the classic dining philosophers problem show that causal compression is rather efficient both time- and space-wise. State of the art verification tools can successfully handle more than 15 agents, whereas they can handle no more than 5 following the traditional direct method; an altogether spectacular improvement, since in this example the specification size is exponential in the number of agents.