concurrency on autosys

Fully Synchronous

Mon, 13 Feb 2017 00:00:00 +0000

A buffer is used for communication between objects which run in different threads. A buffer wraps some shared memory or a unique pointer thereto. The buffer may be accessed by the two communication partners via reference to the buffer which is initialized via constructor argument.

A buffer is a single block of memory for a message (or unique pointer) and messages are not queued. Check out the channel if you need communication via a message queue. There are different ways to use a buffer for communication. Either it is ensured that the producer waits until the latest message has been read by the consumer, and the consumer waits until a new message has been provided by the producer. This is called fully synchronous buffer (fsb). No messages are lost or repeatedly read.

Another possibility is the contiuous write buffer, where the producer does not wait for the consumer to read and overwrites messages. Messages may be lost in this case if the consumer read slower than the producer writes. The contiuous asynchronous buffer (cab) does not wait on either side. The consumer may read the same message if no new messages are provided by the producer.

This code example shows how the full_sync_buffer is used. Three thread objects are created (producer, broker, consumer). A message is created in the producer, which is passed on to the broker which passes it on to the consumer. Two buffers are used to realize this (lines 108 and 109), which are given to the thread objects via constructor argument (lines 110 - 112). Broker and Consumer block on the get-call and wait for the message to arrive. The Producer blocks on the put-call until the receiver is ready to receive (i.e. until the buffer is empty). This way the communication is synchronized.

Once the broker has passed on the message, the producer could go on and send the next message to the broker (not shown in the code) while the consumer might still be busy with the first message. The producer needs to create new memory for each message. A unique pointer to the message is passed on between the communication partners. Be aware at this point, that the new call will take a lot of time if used frequently. It is a good idea to use a memory pool at this place.

The memory of the message is automatically cleaned up by the use of a unique pointer. This happens in the moment the unique pointer in the consumer is overwritten by the next message.

Semaphore

Mon, 13 Feb 2017 00:00:00 +0000

Object-oriented semaphores are not part of the C++ standard at this point. However, it is possible to implement a semaphore class using a mutex and a condition variable both of which where added to the standard in C++11.

For the implementation shown on this website the function names where derived from the POSIX semaphores. The post function increases the count of the semaphore and notifies a thread that might be waiting on the semaphore if its count is at zero. The wait function decreases the semaphore count and blocks if the count reaches zero. Any thread calling wait when the count is at zero waits on the condition variable until notified that the count has increased.

A variation on this function is the try_wait function which does not block but simply return its success in acquiring the semaphore in the form of a bool.

Thread Control

Mon, 13 Feb 2017 00:00:00 +0000

How to stop a thread.

It is a nice idea to create a functor (overload operator()) and pass a functor object to a thread. The operator()() (line 9) should generally contain a while loop (event loop)(line 10). To be able to stop the while loop from the outside, one can use a member variable of the functor, e.g. bool IsStopped or bool IsRunning (line 15). The loop would then look like this

while(IsRunning){...}

Another thread (e.g. the main thread) could then set the flag to true (or false) (line 23) and this will end the while loop.

In order to make this work, the functor object has to be passed as a reference to the thread (line 20).

thread(std::ref(thread01));

If you need more sophisticated communication between threads, you should use the buffer or channel which are described in separate posts.