Download it here.

Async provides a simple process pool that allocates a number of worker threads
that may then be utilized collectively without having to deal directly with
threads. Results of jobs sent to the pool are “future” objects, called Asyncs.
Asyncs’ values are then acquired by calling Async.sync, which blocks until the
value has been set by the pool. A supervisor thread monitors the worker threads
and restarts any that terminate abnormally.

Usage is simple:

// create a pool of four processes
Pool pool = Pool(4)
 
// send a job to the pool
Async result = Pool->send(exp, 10);
 
// get the result
result->sync();
// => 22026.46484375
 
// alternately, you can call an async
result();
// => 22026.46484375
 
// pools can conveniently map across a sequence
Async mapped_result = pool->map(exp, enumerate(5));
mapped_result->sync();
// => ({ 1.0, 2.718281745910645, 7.389056205749512, 20.08553695678711, 54.59814834594727 })
 
// or iterate without collecting return values
int x = 0;
pool->iter(lambda (int n) { x += n; }, enumerate(100));
write("%d", x);
// => 4950
 
// close the pool, blocking until all workers have terminated
pool->close();

Submit article

The initial problem was getting it to find the MySQL headers and libraries installed by macports, which was easy enough to fix.

LDCONFIG="-L/opt/local/mysql/lib"
export LDCONFIG
CPPFLAGS="-I/opt/local/include/mysql5"
export CPPFLAGS

It found the files it needed, but it still didn’t pass the test.  It complained about not finding various API functions in the MySQL library. It turns out that it was detecting my system as 64bit (when it is in fact 32).  For that, I had to run make with CONFIGUREARGS:

make CONFIGUREARGS="--with-abi=32"

…and that did it.  Thank god for the good folks in #pike on irc.freenode.net!

Submit article

The Thread module in the standard library provides a complete system for multi-threading. Initially, a thread is created by instantiating a new instance of the Thread.Thread class with a function that will be executed in a new thread and any arguments to that function:

void say_hello(string name)
{
    write("Hello, " + name + ".\n");
}
 
int main()
{
    Thread.Thread thread;
    thread = Thread.Thread(say_hello, "Jeff");
 
    return -1; // return -1 so execution does not terminate
}

Pike’s interpreter is completely thread-safe. All execution is protected by a global interpreter lock, similar to that of Python. Unlike Python, however, Pike’s locking is finely grained and released often, making threads quite useful in Pike.

Thread.Mutex and Thread.MutexKey

Mutexes are required to protect critical sections that must be executed atomically. Thanks to the interpreter lock, no two threads will ever access the same variable concurrently. However, if a variable is modified or accessed multiple times in a thread, a mutex must be used to guard it:

Thread.Mutex m = Thread.Mutex(); // create a mutex
void func()
{
    Thread.MutexKey k = m->lock(); // acquire the lock
 
    ... // do stuff
    ... // do more stuff
 
    return;
}

Notice that the mutex was never released. Once the MutexKey (returned by Mutex->lock()) goes out of scope, the mutex is automatically released. This means that a method can be made to be synchronized simply by acquiring a lock at the beginning of the function.

Thread.Condition

Condition variables are used to synchronize events across multiple threads. A thread controlling a resource holds a condition variable, with other threads waiting for the condition to be signaled. The controlling thread may chose to signal just one or all waiting threads at once.

A MutexKey must be provided by the waitin thread to guarantee synchronicity with the signaling thread.

Thread.Mutex mutex = Thread.Mutex();
 
void consumer(Thread.Condition c, Thread.Condition c2)
{
    while (1) {
        Thread.MutexKey key = mutex->lock();
        c->wait(key);
        key = 0;
        write("Pong!\n");
        c2->signal();
    }
}
 
void producer(Thread.Condition c, Thread.Condition c2)
{
    while (1) {
        Thread.MutexKey key = mutex->lock();
        c2->wait(key);
        key = 0;
        write("Ping!\n");
        c->signal();
    }
}
 
int main()
{
    Thread.Condition condition1, condition2;
    Thread.Thread prod, cons;
    condition1 = Thread.Condition();
    condition2 = Thread.Condition();
    prod = Thread.Thread(producer, condition1, condition2);
    cons = Thread.Thread(consumer, condition1, condition2);
    condition2->signal(); // get the producer started
    return -1; // keeps script running
}

In this way, a condition variable is akin to a simplified counting semaphore, which may be incremented n times to signal n waiting threads.

Thread.Local

Thread-local storage may be created with Thread.Local:

string thread_fn()
{
    Thread.Local data = Thread.Local();
 
    data->set("foo");
    return data->get();
}

Thread.Queue

Queues are first in, first out containers.
Thread.Queue is expandable, so pushing new elements into the queue will not block:

void consumer(Thread.Queue q)
{
    while (1) {
        string value = q->read(); // block until value available
        do_something_with(value);
    }
}

Another interesting method is read_array, which reads as many values as are available. This is extremely useful. Reading a batch of work results in less time spend blocking, making active queues much more efficient.

Thread.Fifo

The primary difference between the Queue and Fifo classes is that the Fifo class is bounded and will block on writes when full.

void producer(Thread.Fifo q)
{
    string value;
    while (1) {
        value = get_value_from_somewhere();
        q->write(value); // blocks until space is available
    }
}

Conclusion

Pike makes threading easy on programmers. Pike’s internals are thread-safe; a programmer never needs to worry about corrupting memory. Mutually exclusive locks are only used to protect blocks of code that must be executed without interruption, so that only the concurrency of the overall technique must be considered.

Submit article