DenkzeitWiki

Concurrent Programming

• http://www.awprofessional.com/articles/article.asp?p=167813
  
• The Free Lunch Is Over: A Fundamental Turn Toward Concurrency in Software by HerbSutter
  • via http://ischenko.blogspot.com/2005/02/pressure-for-concurrency.html
    
  
  
• http://www.tbray.org/ongoing/When/200x/2005/08/02/Joy-of-Threads --The Joy of Threads
  
• http://www.nedbatchelder.com/blog/200509.html#e20050906T073902 --Threads cannot be implemented as a library

Threads are not the answer. Threads are the question. No is the answer. Why? Scalable != threading. Scalable == clustered / peer to peer / grid.[1]

• Locks
  • mutex semaphores
• Semaphore
  • manages shared resources
  • The Little Book of Semaphores, free online book on ConcurrentProgramming
• Monitor
  • A monitor is essentially a shared class with explicit queues. [2]
    • shared class: all variables private, all methods synchronized (in Java)
    • explicit queue: queue of threads waiting for some condition to hold.
  • Higher-level synchronization
  • http://en.wikipedia.org/wiki/Monitor_(synchronization)
• Transaction (SoftwareTransactionalMemory)
  • Lock that can abort or commit

• Concur.next - initiated by TimBray
  
  
• http://www.sauria.com/blog/2009/10/05/the-cambrian-period-of-concurrency/
  • http://www.slideshare.net/twleung/a-survey-of-concurrency-constructs
  • http://kenai.com/projects/divide-and-conquer/pages/Home
  • http://www.dabeaz.com/python/GIL.pdf - on Python's GIL
  • http://www.infoq.com/presentations/Value-Identity-State-Rich-Hickey - RichHickey of Clojure

• Multithreading is a verb not a noun
  • But, at the end of the day, the noun-ness of mainstream OO languages makes multithreading no better than miserable to work in.
  • MessageOrientedProgramming?
    
  
  
• Misguided: The Road Not To Be Travelled

We need to be headed primarily toward shared *nothing*. Sharing at the level prescribed in this paper, whether with locks or transactions, is simply uncalled for 99% of the time. Sequential processes with shared-nothing message passing should be the direction.

• The Trouble with Locks by HerbSutter

Lock-based programming, our status quo, is difficult for experts to get right. Worse, it is also fundamentally flawed for building large programs.
...
Lock-free programming is difficult for gurus to get right.

• Multithreading tutorial, part one: Introduction
  
• Excellent Brief Read on Multicore Software
  • http://www.cilk.com/multicore-e-book/

• http://www.multicore-association.org/

• Use Critical Sections (Preferably Locks) to Eliminate Races

Concurrency Vs. Parallelism

• http://ghcmutterings.wordpress.com/2009/10/06/parallelism-concurrency/
  • Concurrency: arbitrarily interleaved threads -> non-deterministic (because dependent on interleaving)
    • control interleaving with synchronisation
  • parallelism: running on multiple cores, hopefully faster than on single core
  • in side-effecty languages, the only way to get parallelism is concurrency; it’s therefore not surprising that we often see the two conflated.
  
  
• A Kid's Guide to Concurrency And Parallelism
  • fetching balls
  
  
• http://www.danielmoth.com/Blog/2008/11/threadingconcurrency-vs-parallelism.html
  • On a multi-core machine there is an additional opportunity to improve the actual performance of your compute bound operations, by bringing parallel programming into the picture.
  • Another way of putting it is that on a single core you can use threads and you can have concurrency, but to achieve parallelism on a multi-core box you have to identify in your code the exploitable concurrency: the portions of your code that can truly run at the same time.
  
  
• http://www.sauria.com/blog/2009/10/06/concurrency-parallelism/
  • parallel execution of a concurrent program
  
  
• http://blogs.sun.com/yuanlin/entry/concurrency_vs_parallelism_concurrent_programming
  • concurrency: non-determinism (order of execution)
  • Concurrency and parallelism are NOT the same thing. Two tasks T1 and T2 are concurrent if the order in which the two tasks are executed in time is not predetermined,
  • If two concurrent threads are scheduled by the OS to run on one single-core non-SMT non-CMP processor, you may get concurrency but not parallelism. Parallelism is possible on multi-core, multi-processor or distributed systems.
  • Concurrency is often referred to as a property of a program, and is a concept more general than parallelism.
  
  
• http://www.info.ucl.ac.be/~pvr/VanRoyChapter.pdf
  • For example, a client/server application with two clients is nondeterministic since the server does not know from which client the next command will come.
    • The client and server implementations can themselves be completely deterministic.
  • Concurrency should not be confused with parallelism. Concurrency is a language concept and parallelism is a hardware concept. Two parts are parallel if they execute simultaneously on multiple processors. Concurrency and parallelism are orthogonal: it is possible to run concurrent programs on a single processor (using preemptive scheduling and time slices) and to run sequential programs on multiple processors (by parallelizing the calculations).
  
  
• Concurrent/Parallel Programming - The Next Generation by BillClementson?
  • summary, links, Lisp
  • http://www.tbray.org/ongoing/When/200x/2005/06/12/Threads

• http://msdn.com/concurrency

• http://channel9.msdn.com/shows/Going+Deep/E2E-Erik-Meijer-and-Burton-Smith-Concurrency-Parallelism-and-Programming/

• Guy Steele: How To Think About Parallel Programming—Not! via http://www.weiqigao.com/blog/2010/10/18/strange_loop_2010_two_questions_not_answered.html

Languages

Oz

• http://www.mozart-oz.org/

Python Python

• http://www.stackless.com/wiki/Tasklets --Stackless Python -Tasklets
• http://www.informit.com/articles/article.asp?p=23294 --Stackless Python -Microthreads
• http://www.python.org/workshops/1997-10/proceedings/atom/atom.html --in Python with atom

• http://linuxgazette.net/107/pai.html --Understanding Threading in Python
• http://docs.python.org/lib/module-threading.html --Threading-module in python
  Bildet Threading von Java nach.
  • http://codepoetics.com/poetix/index.php?p=80 --concurrent.py --wapping threading
• http://thraxil.org/users/anders/posts/2003/10/15/python-threading/ --kleines script
• http://www-106.ibm.com/developerworks/linux/library/l-pythrd.html --weightless threads with generators
• POSH-module

Java

• http://docs.rinet.ru/JWP/ch16.htm
• http://java.sun.com/docs/books/tutorial/essential/threads/
• http://www-106.ibm.com/developerworks/java/library/j-jtp10264/ --More flexible, scalable locking in JDK 5.0 -java.util.concurrent.lock
• Concurrent Programming Using Java
• http://www.mcs.drexel.edu/~shartley/ConcProgJava/
  
• http://www.slideshare.net/jboner/state-youre-doing-it-wrong-javaone-2009

Erlang

• ActorModel

Introductions

• http://coronet.iicm.edu/sa/scripts/swp8.pdf
• http://www.iam.unibe.ch/~scg/Archive/Lectures/CP-W99.pdf --grosses Vorlesungsskript
• http://www.cswl.com/whiteppr/white/concurrent.html --anmeldung
  
• http://www.ocf.berkeley.edu/~fricke/threads/threads.html

• http://pauillac.inria.fr/join/manual/manual002.html
• http://burks.brighton.ac.uk/burks/pcinfo/progdocs/plbook/concurre.htm

Message Passing

• MSMQ
• Biz Server
• PyLinda

MultiThreading with Python

• http://code.google.com/p/papyros/
  • Papyros is a small platform independent parallel processing Python package, providing a master-slave model. Clients can submit jobs to a master object which is monitored by one or more slave objects that do the real work.
    
  
  
• http://cheeseshop.python.org/pypi/processing
  • Package for using processes mimicking the `threading` module
• http://pypi.python.org/pypi/pprocess
  • The pprocess module provides elementary support for parallel programming in Python using a fork-based process creation model in conjunction with a channel-based communications model implemented using socketpair and poll.
    
  
  
• Parallel Python, BruceEckel
• http://www.parallelpython.com/
  • pp is a python module which provides mechanism for parallel execution of python code on SMP (systems with multiple processors or cores) and clusters (computers connected via network)
    

• http://ipython.scipy.org/moin/Parallel_Computing
• http://pypi.python.org/pypi/FibraNet/
• http://www.boddie.org.uk/python/pprocess/tutorial.html
  
  
• http://candygram.sourceforge.net/ updated 2004
  

• The Concurrency Model Debate
• GIL of Doom!
  • Thread State and the Global Interpreter Lock
• Needled by threads
  • kick it old school with multiple processes, coroutines, and asynchronous IO
• Wiki:ConceptsTechniquesAndModelsOfComputerProgramming
  
  
• Concurrent Object-Oriented Programming in Python with ATOM
  
• Concurrency, good introduction
  
• Wikipedia:Thread_(computer_science)
• Concurrent Programming

Distributed Concurrency

• [erlang-questions] Erlang vs Clojure

The ErlangVM enables distributed concurrency, Closure on the JVM is optimizing for local concurrency.