Concurrent C is an extension of the C programming language which provides facilities for parallel programming. It has been implemented on uni-processors under UNIX, on tightly coupled multiprocessors with shared memory, and on loosely coupled systems of unlike machines connected by a LAN.
The language allows for the dynamic creation of processes. A process type must first be declared, after which multiple process instances of that type can be created. The declaration syntax separates the interface part of the process from the implementation in the interests of readability.
A blocking send mechanism called a “transaction,” which allows for bidirectional information flow, provides interprocess communication; parameters are passed to the target process, and a result is returned to the caller. Within the target process, a transaction is received by an “accept” statement. Sender and receiver synchronize at this rendezvous. The receiver eventually executes a “treturn” to return a value to the sender, which then resumes execution. The accept statement has numerous optional clauses, including facilities to restrict acceptance of transactions to those specifying some condition, or in some specific order, while allowing a timeout to withdraw the transaction if it is not handled within a certain time. Though synchronous message passing is the approved model, the system provides facilities for asynchronous messages as well, and the authors include much discussion of their respective merits. Those who insist can even use communication by shared global variables, though its meaning on an implementation with no shared memory is undefined. Processes can delay themselves for an interval of real time, and hardware interrupts can be converted to transactions. The language appears to be an extremely clean, flexible, and powerful notation for expressing concurrent solutions, and its designers have clearly learned enormously from the infelicities of Ada. The background culture of C does reveal itself in the features left as implementation dependent. A version of the language combined with C++ is available, and the authors present this version well, together with some treatment of when things are better hidden in processes rather than objects.
The book is aimed at those who have some familiarity with the ideas of concurrency as well as an acquaintance with C, though an appendix summarizes the C language. The exposition is largely by means of well-chosen examples, which range in size from dining philosophers and alternating bit protocols to window managers and discrete event simulation. The book includes excellent chapters that discuss design issues for concurrent languages, useful appendices that give information on the implementation, and an illuminating comparison with Ada.
Occasionally I felt that the treatment of some of the more difficult constructs could have been rather fuller, and I would have welcomed more on program design issues such as which entities to make active and which passive. On the whole, though, the book is a model of how a new language should be presented, and I can strongly recommend it to anyone interested in this area of programming, whether or not they intend to use the language.
