thread

Related: cloth, concurrent, CPU, fiber, memory, process, schedule

TinyThreadLib.sf.net >>TinyThread Lib is a very lightweight C++ thread library which acts as a wrapper around either pthreads or the analogous Win32 API functions to provide classes for threads and synchronization objects for multithreaded programming.

www.CodeProject.com/KB/cpp/FastDelegate.aspx >>Standard C++ does not have true object-oriented function pointers. This is unfortunate, because object-oriented function pointers, also called 'closures' or 'delegates', have proved their value in similar languages. In Delphi (Object Pascal), they are the basis for Borland's Visual Component Library (VCL). More recently, C# has popularized the delegate concept, contributing to the success of that language. For many applications, delegates simplify the use of elegant design patterns (Observer, Strategy, State[GoF]) composed of very loosely coupled objects. There can be no doubt that such a feature would be useful in standard C++.

Flounder.com/fibers.htm >>This project came about when I encountered a client that needed a fiber scheduler.  The problem arose because of a need to convert non-preemptive "threads" from an existing programming domain to Windows.  [This was part of my teaching, not part of a contract, and I presented this solution in class; therefore I was not actually paid to write it, and it remains mine.  Just so you know that this wasn't proprietary work.]

XMailServer.org/libpcl.html >>The Portable Coroutine Library (PCL) implements the low level functionality for coroutines. For a definition of the term coroutine see The Art of Computer Programming by Donald E. Knuth. Coroutines are a very simple cooperative multitasking environment where the switch from one task to another is done explicitly by a function call. Coroutines are a lot faster than processes or threads switch, since there is no OS kernel involvement for the operation. Also coroutines require much less OS resources than processes of threads. The idea of writing this library started when I was testing Linux epoll functionality and performance. I initially started using the coro library by E. Toernig <froese@gmx.de> and I found the library very interesting. It was simple and yet powerful. The limitations of the coro library were both non portability and crashes when not used together with certain versions of gcc. So I decided to write a new library to address the problems aforementioned by also taking portable context switching ideas from the GNU Pth library. This library is easily portable on almost every Unix system and on Windows. It can use either the ucontext.h functionalities ( getcontext()/mak econtest()/swapcontext() ) or the standard longjmp()/setjmp().

www.SEAS.UPenn.edu/~lipeng/homepage/unify.html >>This project uses a language-based technique to unify two seemingly opposite programming models for building massively concurrent net work services: the event-driven model and the multithreaded model.  The result is a unified concurrency model providing both thread abstractions and event abstractions.  We implemented the unified concurrency model in Haskell, a pure, lazy, functional programming language. Our implementation demonstrates how to use these techniques by building an application-level thread library with support for multiprocessing and asynchronous I/O mechanisms in Linux.  The thread library is type-safe, is relatively simple to implement, and has good performance.  Application-level threads are extremely lightweight (scaling to 10,000,000 threads!) and our scheduler, which is implemented as a modular and extensible event-driven system, outperforms NPTL in I/O benchmarks.

State-Threads.sf.net >>The State Threads Library is a small application library which provides a foundation for writing fast and highly scalable Internet applications (such as web servers, proxy servers, mail transfer agents, and so on, really any net work-data-driven application) on UNIX-like platforms. It combines the simplicity of the multithreaded programming paradigm, in which one thread supports each simultaneous connection, with the performance and scalability of an event-driven state machine architecture. In other words, this library offers a threading API for structuring an Internet application as a state machine.

LinuxInsight.com/files/downey05semaphores.pdf >>The Little Book of Semaphores is a free (in both senses of the word) textbook that introduces the principles of synchronization for concurrent programming.

liboop.OFB.net >>Liboop is a low-level event loop management library for POSIX-based operating systems. It supports the development of modular, multiplexed applications which may respond to events from several sources. It replaces the "select() loop" and allows the registration of event handlers for file and net work I/O, timers and signals. Since processes use these mechanisms for almost all external communication, liboop can be used as the basis for almost any application.

Monkey.org/~provos/libevent >>The libevent API provides a mechanism to execute a callback function when a specific event occurs on a file descriptor or after a timeout has been reached. Furthermore, libevent also support callbacks due to signals or regular timeouts.  libevent is meant to replace the event loop found in event driven net work servers. An application just needs to call event_dispatch() and then add or remove events dynamically without having to change the event loop.

Kegel.com/c10k.html >>It's time for web servers to handle ten thousand clients simultaneously, don't you think? After all, the web is a big place now.

Tenermerx.com/Asio >>Asio is a cross-platform C++ library for net work and low-level I/O programming that provides developers with a consistent asynchronous model using a modern C++ approach.

http://www.cs.wustl.edu/~schmidt/ACE.html Is an older version of ASIO

ZThreads.sf.net >>A platform-independent, multi-threading and synchronization library for C++

NPTLTraceTool.sf.net >>The POSIX Thread Trace Toolkit (PTT) is a library-level trace tool for. the glibc (GNU C library) thread library (Native POSIX Thread Library or NPTL). It aims to help users to analyze and debug multi-threaded applications using the NPTL under Linux systems.

SICS.se/~adam/pt >>Protothreads are extremely lightweight stackless threads designed for severely memory constrained systems, such as small embedded systems or wireless sensor net work nodes. Protothreads provide linear code execution for event-driven systems implemented in C. Protothreads can be used with or without an underlying operating system to provide blocking event-handlers. Protothreads provide sequential flow of control without complex state machines or full multi-threading.

And.org/texts/threads >>When a lot of people speak about "multi-threading" there is often this black and white view of the world where on one side you create mutliple threads that share all state and use mutexes etc. and on the other every single instruction from your application to the device driver is completely syncronous.