Kamaelia - Concurrency made useful, fun In Kamaelia you build systems from simple components that talk to each other. This speeds development, massively aids maintenance and also means you build naturally concurrent software. It's intended to be accessible by any developer, including novices. What sort of systems? Network servers, clients, desktop applications, pygame based games, transcode systems and pipelines, digital TV systems, spam eradicators, teaching tools, and a fair amount more :)
The Little Book of Semaphores is a free (in both senses of the word) textbook that introduces the principles of synchronization for concurrent programming. In most computer science curricula, synchronization is a module in an Operating Systems class. OS textbooks present a standard set of problems with a standard set of solutions, but most students don't get a good understanding of the material or the ability to solve similar problems. The approach of this book is to identify patterns that are useful for a variety of synchronization problems and then show how they can be assembled into solutions. After each problem, the book offers a hint before showing a solution, giving students a better chance of discovering solutions on their own. The book covers the classical problems, including "Readers-writers," "Producer-consumer", and "Dining Philosophers." In addition, it collects a number of not-so-classical problems
Communication and Concurrency Lectures take place Monday and Thursday 14.00-14.50 in Appleton Tower, room M1, and are given by Colin Stirling. The syllabus of this module can be viewed in HTML through the Course Guide Background Reading: Milner's book "Communication and Concurrency, Prentice-Hall 1989" is important. Here is some background reading on ordinary, list, and tree (=structural) induction: ps pdf The Wikipedia article on Modal Logic makes interesting background reading. Note that there is a pointer to, but no article for, Hennessy-Milner logic: maybe you would like to write it?
with Philippa Gardner, Term 1, 2007/2008. Recommended Textbooks R. Milner. Communicating and Mobile Systems: the pi-Calculus. Cambridge University Press, various editions. (Introductory) D. Sangiorgi and D. Walker. The pi-Calculus: a Theory of Mobile Processes. Cambridge University Press, 2001. Online References and Tutorials A Calculus for Mobile Processes (Parts I/II) (by Robin Milner, Joachim Parrow, and David Walker). Also available from this site: [ Part I] [ Part II] The Polyadic Pi-Calculus: A Tutorial (by Robin Milner). Also available from this site: [(Postscript)] An Introduction to the Pi-calculus (by Joachim Parrow) A Brief Introduction to Applied Pi (by Peter Sewell) Asynchronous process calculi: the first-order and higher-order paradigms (Tutorial) (by Davide Sangiorgi)
Disco is an oss implementation of the Map-Reduce framework for distributed computing. Disco supports parallel computations over large data sets on unreliable cluster of computers. The Disco core is written in Erlang. Users of Disco typically write jobs in Python, which makes it possible to express even complex algorithms or data processing tasks often only in tens of lines of code. This means that you can quickly write scripts to process massive amounts of data. Disco was started at Nokia Research Center as a lightweight framework for rapid scripting of distributed data processing tasks. This far Disco has been succesfully used, for instance, in parsing and reformatting data, data clustering, probabilistic modelling, data mining, full-text indexing, and log analysis with hundreds of gigabytes of real-world data. Linux is the only supported platform but you can run Disco in the Amazon's Elastic Computing Cloud.
We have designed, implemented, and evaluated AtomCaml, an extension to Objective Caml that provides a synchronization primitive for atomic (transactional) execution of code. A first-class primitive function of type (unit->'a)->'a evaluates its argument (which may call other functions, even external C functions) as though no other thread has interleaved execution. Our design ensures fair scheduling and obstruction-freedom. Our implementation extends the Objective Caml bytecode compiler and run-time system to support atomicity. A logging-and-rollback approach lets us undo uncompleted atomic blocks upon thread pre-emption, and retry them when the thread is rescheduled. The mostly functional nature of the Caml language and the Objective Caml implementation's commitment to a uniprocessor execution model (i.e., threads are interleaved, not executed simultaneously) allow particularly efficient logging.
JoCaml is Objective Caml plus (&) the join calculus, that is, OCaml extended for concurrent and distributed programming. The new JoCaml is a re-implementation of the now unmaintained JoCaml by Fabrice Le Fessant. With respect to this previous implementation, main changes are: * Numerous syntax changes, we believe the new syntax to be cleaner. * Disparition of mobility features, sacrified for the sake of OCaml compatibility. * Much better compatibility with Objective Caml. o Source compatibility is about 99%, there are three new keywords (def, reply and spawn) ; or and & should definitely not be used as boolean operators. o Binary compatibility for matching versions.
RP has extremely good performance and scalability properties. Many uses of RP in the Linux Kernel have resulted in several orders of magnitude performance improvement compared to locking and transactional memory. Is it easy to program with? RP is not difficult to program with. Allowing each execution sequence to proceed using its own view of memory, by default, simplifies concurrent programming because it prevents memory from changing spontaneously. Threads are guaranteed to observe coherent memory, i.e., memory will contain values that were actually written at some time in the past. Read paths also exhibit deterministic performance characteristics, since they can not block or retry. This feature simplifies programming of time-sensitive systems. Nevertheless, RP is a new programming paradigm with a new interface and there are several ways to misuse it. Read Copy Update (RCU), an early example of RP, has seen extensive use in the Linux Kernel at over 2000 uses
One of those things I have to do fairly often in multithreaded programming is send off a whole bunch of threads to do their thing while I do something else on the main thread until they’re done. For example, imagine you’re downloading a bunch of images from the web, you don’t want to call httpGet one image right after another, because network resources are slow and processing them takes up almost no CPU time. But on the other hand, forkIO doesn’t return anything, so a thread thunk will have to put its contents somewhere you can access them later. Thus, my short, simple solution, far too small to bother putting up on Hackage: module Control.Concurrent.Future where import Control.Concurrent future :: IO a -> IO (MVar a) future thunk = do ref <- newEmptyMVar forkIO $ thunk >>= putMVar ref return ref forceAll :: [MVar a] -> IO [a] forceAll = mapM takeMVar
MINA is a simple yet full-featured network application framework which provides:
* Unified API for various transport types:
o TCP/IP & UDP/IP via Java NIO
o Serial communication (RS232) via RXTX
o In-VM pipe communication
o You can implement your own!
* Filter interface as an extension point; similar to Servlet filters
* Low-level and high-level API:
o Low-level: uses ByteBuffers
o High-level: uses user-defined message objects and codecs
* Highly customizable thread model:
o Single thread
o One thread pool
o More than one thread pools (i.e. SEDA)
* Out-of-the-box SSL · TLS · StartTLS support using Java 5 SSLEngine
* Overload shielding & traffic throttling
* Unit testability using mock objects
* JMX managability
* Stream-based I/O support via StreamIoHandler
* Integration with well known containers such as PicoContainer and Spring
* Smooth migration from Netty, an ancestor of Apache MINA.
JPPF enables applications with large processing power requirements to be run on any number of computers, in order to dramatically reduce their processing time. This is done by splitting an application into smaller parts that can be executed simultaneously on different machines.
Jetlang provides a high performance java threading library. The library is based upon Retlang.
The library is a complement to the java.util.concurrent package introduced in 1.5 and should be used for message based concurrency similar to event based actors in Scala.
The library does not provide remote messaging capabilities. It is designed specifically for high performance in-memory messaging.
Features¶
* All messages to a particular Fiber are delivered sequentially. Components can easily keep state without synchronizing data access or worrying about thread races.
* Single Fiber interface that can be backed by a dedicated thread or a thread pool.
* Supports single or multiple subscribers for messages.
* Subscriptions for single events or event batching
* Single or recurring event scheduling
* High performance design optimized for low latency and high scalability
* Publishing is thread safe, allowing easy integration with other threading models.
* Low Lock Contention - Minimizing lock contention is critical for performance. Other concurrency solutions are limited by a single lock typically on a central thread pool or message queue. Jetlang is optimized for low lock contention. Without a central bottleneck, performance easily scales to the needs of the application.
* Powerful Async Request/Reply Support
* Single jar with no dependencies except the jdk (1.6+)
* Integrates with any JVM language - jruby, scala, clojure, groovy, etc
Akka is the platform for the next generation event-driven, scalable and fault-tolerant architectures on the JVM
We believe that writing correct concurrent, fault-tolerant and scalable applications is too hard. Most of the time it's because we are using the wrong tools and the wrong level of abstraction.
Akka is here to change that.
Using the Actor Model together with Software Transactional Memory we raise the abstraction level and provides a better platform to build correct concurrent and scalable applications.
For fault-tolerance we adopt the "Let it crash" / "Embrace failure" model which have been used with great success in the telecom industry to build applications that self-heals, systems that never stop.
Actors also provides the abstraction for transparent distribution and the basis for truly scalable and fault-tolerant applications.
Akka is Open Source and available under the Apache 2 License.
Parallel4 is a easy-to-use multi-threading API for Java an other JVM based languages like Groovy. It offers parallel versions of the "for" and "foreach" loops to leverage the full power of todays multi-core CPUs.
Parallel4's goals are:
* Simple API: Hide as many details of multi-threaded programming as possible from the API. Although it does not offer transparent/implicit multi-threading in a strict sense, it tries to come as close to this as a non-functional programming language allows.
* Familiar API: Offer well known constructs, e.g. the "for" loop and add parallelism to it.
* Easy adaptation of parallel programming: Based on a familiar API, it is easy to introduce multi-threading. Often, two additional lines of code are enough without imposing any structural changes.
* Adaptive: Let the "framework" make reasonable defaults to adapt to the execution environment, e.g. use as many threads as CPU cores are available.
* Performance: A low overhead makes it easy to decide whether to use parallel processing or not.
* Reliable: Multi-threading gets tricky when things go wrong unexpectedly. A well defined exception handling makes this a bit easier.
Kilim is a message-passing framwork for Java that provides ultra-lightweight threads and facilities for fast, safe, zero-copy messaging between these threads.
The process of writing large parallel programs is complicated by the need to specify both the parallel behaviour of the program and the algorithm that is to be used to compute its result.
In an earlier post Over on the Twisted blog, Duncan McGreggor has asked us to expand a bit on where we think Twisted may be lacking in it’s support for concurrency. I’m afraid this has turned into a meandering essay, since I needed to reference so muc
The Little Book of Semaphores is a free (in both senses of the word) textbook that introduces the principles of synchronization for concurrent programming.
In most computer science curricula, synchronization is a module in an Operating Systems class. OS textbooks present a standard set of problems with a standard set of solutions, but most students don't get a good understanding of the material or the ability to solve similar problems.
The approach of this book is to identify patterns that are useful for a variety of synchronization problems and then show how they can be assembled into solutions. After each problem, the book offers a hint before showing a solution, giving students a better chance of discovering solutions on their own.
The book covers the classical problems, including "Readers-writers", "Producer-consumer", and "Dining Philosophers". In addition, it collects a number of not-so-classical problems, some written by the author and some by other teachers and textbook writers. Readers are invited to create and submit new problems.
PARLEY is an API for writing Python programs that implement the Actor model of distributed systems, in which lightweight concurrent processes communicate through asynchronous message-passing.
A collection of Concurrent and Highly Scalable Utilities. These are intended as direct replacements for the java.util.* or java.util.concurrent.* collections but with better performance when many CPUs are using the collection concurrently.
This package is the backport of java.util.concurrent API, introduced in Java 5.0 and further refined in Java 6.0, to older Java platforms. The backport is based on public-domain sources from the JSR 166 CVS repository, the dl.util.concurrent package, and
I participated in the design and development of a couple of concurrency libraries for shared-memory multiprocessors long before such machines were popular. So when I started using java.util.concurrent I was already somewhat comfortable with the concepts.
The C++ standardization committee is hard at work standardizing threads for the next version of C++. Some members recently met to discuss the issues, and The C++ Source was there. Read on to learn what the world’s leading experts on concurrency are plan
Candygram is a Python implementation of Erlang concurrency primitives. Erlang is widely respected for its elegant built-in facilities for concurrent programming. This package attempts to emulate those facilities as closely as possible in Python. With Candygram, developers can send and receive messages between threads using semantics nearly identical to those in the Erlang language.
The Java™ programming language made starting a new thread easier than ever before. But freeing your concurrent programs of obscure bugs is a different matter, and Java's programming model might not be the best available. A language called Erlang is getting some good press now in the areas of concurrency, distributed systems, and soft real-time systems.
Chapters: History, sequential programming, concurrent programming, error handling, advanced topics
They say it takes four days to complete the course. If you know a little Prolog and a little LISP it takes you rather a few hours.
S. Marr, M. Haupt, and T. D'Hondt. Proceedings of the 3rd Workshop on Virtual Machines and Intermediate Languages, page 3:1--3:2. New York, NY, USA, ACM, (October 2009)(extended abstract).
M. Herlihy, and J. Wing. POPL '87: Proceedings of the 14th ACM SIGACT-SIGPLAN symposium on Principles of programming languages, page 13--26. New York, NY, USA, ACM, (1987)
S. Dekeyser, and J. Hidders. ADC '04: Proceedings of the fifteenth Australasian database conference, page 93--101. Darlinghurst, Australia, Australia, Australian Computer Society, Inc., (2004)
H. Schippers, T. Van Cutsem, S. Marr, M. Haupt, and R. Hirschfeld. Proceedings of the Fourth Workshop on the Implementation, Compilation, Optimization of Object-Oriented Languages, Programs and Systems (ICOOOLPS), page 4--9. ACM, (Jul 6, 2009)
M. Miller, E. Tribble, and J. Shapiro. Symposium on Trustworthy Global Computing, volume 3705 of Lecture Notes in Computer Science, page 195--229. Springer, (April 2005)