Workqueues in Ada

[Wiktor Moskwa <wiktorDOTmoskwa@gmail.com>]

Hello,

Few months ago I wrote about a distributed protocol simulator that
I was writing in Ada. I followed an advice to stop using a thread per
node and to implement a worker thread pool.
With the new architecture things improved a lot, all the overhead
of context switching has gone.

I defined a unit of work as one iteration of one node (checking if
new messages have come, processing messages, sending responses,
checking if it's time to run a periodic job, updating statistic).
I have a workqueue of above units and a pool of tasks that service
nodes.

The problem is that my poor implementation of workqueue is a 
bottleneck. A task takes a unit of work from a queue, processes it 
and puts it back at the and of the queue. Because the queue is 
Ada.Containers.Doubly_Linked_Lists there are lots of memory
allocations and deallocations - that's a performance problem.

I consider making a circular list of nodes with "Next_To_Service"
pointer going around as nodes are processed. I'll have to make
sure that one node can be served by only one task at the time
(probably by marking nodes as being served at the moment).
New nodes joining and old leaving the system will be more
difficult to implement correctly, I suppose.

What can you suggest?
I'm probably missing something obvious. 
Thanks in advance!

-- 
Wiktor Moskwa