resources on autosys

Clone Factory

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

A factory creates objects of a certain type. The factory takes an ID of some sort as an argument and creates the object which has been registered with the factory with the respective ID.

This code sample shows one way to make a factory. All objects are stored in an interal (intrusive) list inside the factory together with their ID. To create an object given its ID, the factory searches the list for the ID and calls the copy constructor of the object to create a new object of the same type.

In the moment the new object comes into live, a so called virtual constructor call is made. The virtual constructor principle simply states, that there shall be a function like create() or construct() or init() which shall be called polymorphically. Real constructors may not be virtual, you see. This is because the object hasn´t been created yet and therefore no v-table exists.

The virtual constructor call may be used e.g. for a deserialization call, in case your factory creates message objects. In this case the virtual constructor reads a byte stream and fill the freshly created object with data.

Memory Pool

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

The memory pool is really fast in allocating and deallocating memory (O(1)). For real-time systems this is the right choice. It works by preallocating a pool of memory blocks. These memory blocks must all have the same size. So this is the downside to live with: This memory pool will only provide memory blocks of a certain size. If you need another size: Simply make another memory pool with that other size. There is also another issue: Memory hogging. Since the memory pools work on preallocated memory, they will never give it back to the operating system.

This source code example shows how the memory pool works. One class is to overwrite new and delete. The other class is to implement the fairly simple memory pool algorithm. Essentially a free stack is used to remember the free memory blocks so that they can be immediately offered to the user upon his new call. A delete will simply put the memory block back to the free stack.

Signal ID to function call in state machines

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

Mapping Signal IDs to function calls

The state machine pattern assumes, that function calls are made by each incoming signal. But what if the signals exist only as a number or ID? How is the ID transformed into a function call? Of course, you could simply write a switch case, converting the integer ID into a function call. But switch cases “smell” (look into Martin Fowlers book on Refactoring).

This example uses the function process(Signal s) (line 61, lines 76 and 77) to process the signal which is given as an ID. Look at line 63 where the respective function is being called (omit lines 62 and 64 in your production code). It´s just one line of code: No switch case. How is this done?

funcArray is an std::vector of member function pointers. The signal ID is simply the index of the respective function in the function pointer array.

The std::vector is initialized in line 67. Lambdas need to be used to store member functions in the function pointer array.

The code also shows how to print the current state using the build-in tool typeinfo.

The code below should compile using the old C++03.

C++03 Source Code Example

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.