Queueable is a library for measuring the tolerance of various communication APIs to concurrent messaging. Queueable aims to discover which backend communication libraries provide the best foundation to build highly concurrent programs.

Queueable consists of a base class interface that should be subclassed for each backend. The base class is designed to minimize developer effort while sharing as much code as possible between backends. For each test, Queueable performs this rough set of steps:

- before_fork() - initialize server resources
- fork()
    - for the server
    - after_fork() - setup server-specific resources
    - test_enqueue - enqueue 1,000,000 items in batches of 1000
    - cleanup() - signal clients to close

    - for each client
    - after_fork() - setup client-specific resources
    - test_dequeue() - dequeue 1,000,000 items in batches of 1000
    - cleanup() - close client-specific resources

This process is repeated up to the maximum number of threads and maximum message size.

Queueable currently supports the following backends:

• TCP Sockets

• Unix Domain Stream Sockets

• Unix Domain Datagram Sockets

• POSIX Message Queues

Queueable uses several default parameters as defined in run_queueable.cpp. These are used to define tests. Queueable is designed to vary both message size and the number of threads up to a maximum. By default, these are message sizes up to 4096 bytes (where supported by the backend) and up to 32 threads.

Queueable should be built with a simple make:

$ make

make creates an executable named run_queueable. It can be invoked manually or using

$ make test

Upon finishing the tests, Queueable will output a single XML file in your local directory with the test results. It will list a curl command to upload the test results to queueable.herokuapp.com .

Upon submitting your results, you will be given a link to add more detailed information about your test results.

Queueable is released under the MIT license. See LICENSE.txt for details.

Adam Lamar