brinkar / rubycsp

CSP (Communicating Sequential Processes) library for Ruby

Ruby CSP

Communicating Sequential Processes library for Ruby.

Introduction

CSP is a formal language for defining concurrent systems that can be verified mathematically, making it possible to prove the correctness of your concurrent system, ie. that there are no deadlocks, race conditions etc. This library is an implementation of CSP in Ruby 1.9 that introduces a new and better way of developing concurrent programs in Ruby, something that can otherwise be very hard.

The library has been influenced by other CSP implementations including PyCSP (for Python), JCSP (for Java), C++ CSP and Occam, with some other concepts introduced to make it more Ruby-ish wherever possible. You can check out the syntax and behaviour of the library by looking at the files in the examples/ and test/ directories. Later on, a more formal tutorial and some API-docs might be created.

Please note that this library only works with Ruby 1.9, and has only been tested on Linux.

Features

Currently implemented featues include:

• Processes.
• Process maps for running processes in parallel.
• Process labelling for easy reusing of processes.
• Channels. Can be shared and buffered.
• Poisoning of channels.
• Read/write restriction using channel ends.
• Some simplifying functions for doing common stuff easily.
• Alternation with input, output, timeout and skip guards.
• Test and example suite.

Planned features:

• OS processes. Distribute CSP processes (fibers) on a number of Ruby processes, making it possible to take advantage of multiple CPU cores.
• Transparent network support. Channels are shared on a TCP socket so that any process can run anywhere on the network.
• Native processes. Creating an easy way to implement your processes in C/++ or Fortran, possibly using the RubyInline gem.
• Visualization and inspection. Automatic graph creation for inspecting your CSP network.
• Logging. Something like CSP traces could be implemented for generic logging and inspection of the state of a system.
• Suspending/resuming processes and networks. If it’s actually usable for anything.
• Mobility. Look into pi-calculus and see if some of the concepts of process and channel mobility could be implemented.
• API docs
• Gem

rubycsp's Issues

Transparent network support

Looking into dRuby and Rinda.

Channel filters

The possibility to define what data a channel accepts.

Process and channel mobility

Pi-calculus defines mobile processes and channels. Would such features be useful?

Running a map in the background

Visualization of maps

Graph creation and inspection of events.

Ruby processes for multi-core utilization

Fork Ruby processes and distribute the CSP processes among them when running a Map. Make it possible to manually decide to which Ruby processes the CSP processes go.

API clean-up

Clean up the framework.

Gem creation

Running a map sequentially

Something like in_parallel that runs the processes in sequence instead of parallel.

Built-in logging

CSP traces is a kind of logging. Look into the possibility of implementing them.

Hooks in alternations

Supply a guard with a block that gets executed when this guard is selected in an alternation.

Suspend/resume maps

Is this usable? If so, how?

API docs

Commenting the code and creating rdoc API.

Waiting uses 100% CPU

Some way of waiting process bookkeeping needs to be made in order for the scheduler to sleep and wake up when something happens.

Native processes

The possibility to implement processes in C, C++ and Fortran. Inline if possible.