Reuse Boost-Thread (von Thread) nach einer Unterbrechung oder steig

Question

Im Moment verwende ich einen Produzenten Consumer-Modell für das Rendering Teil einer Echtzeit-Grafik-Anwendung. Der Verbraucher wird sucht ständig nach Daten in unserer Warteschlange (Endlosschleife); Ich bin jedoch Angst, dass dies meine Simulation verursachen kann synchron von der Hauptschleife raus. Ich denke, das schnellen Produzent langsam Verbraucher Problem -. Durch die Tatsache, dass die Simulation zu einem bestimmten Zeit zurückgehalten wird

Frage - Was ist die beste Methode, dies alles im Gleichgewicht zu halten und sicherzustellen, dass die Verbraucher genügend Zeit bis zum Ende hat, sondern auch, dass die Simulation zum nächsten Bild bewegt sich nicht vor wir werden unsere aktuellen Frame fertig zu machen (oder zumindest in der Lage sein, dies zu erkennen und überspringt den nächsten Frame Rendering - oder unterbrechen die aktuelle Frame gerendert wird) ich bin derzeit nur zu unterbrechen und Verbinden nach jedem Verbraucher beendet

Zweite Frage: , wenn Sie den Code anschauen unten sehen Sie, dass ich derzeit nur Interrupt-Aufruf und kommen nach dem Rendern Jobs in die Warteschlange hinzugefügt - dies ermöglicht den Faden die ganze Zeit es braucht, um Ergänzen seines Betriebes, und auf das Interrupt zu reagieren, wenn fertig. Wie kann ich dann Wiederverwendung Threads in einem Thread-Pool nach interrupt_all und join_all genannt werden? (Das heißt, wenn ich rufe drawNextFrame wieder)

Der Hersteller ist Teil des Haupt-Thread der Ausführung (ich glaube nicht, das wirkt alles)

pseudo code:

void renderSystem::init()
create queue to hold work;
create consumer threads of type RenderConsumer set to watch our queue; 
add threads to thread_pool of consumers called 'RenderThreads'

void renderSystem::drawNextFrame()
for each thread in 'RenderThreads' divy up work; 
add work assignment to queue;
    //RenderThreads will now successfully start pulling data from our queue
renderThreads.interupt_all();
renderThreads.join_all();

int main()
renderer = renderSystem class;
renderer.init()
while(not_gameover)
    renderer.drawNextFrame();
    doOtherCoolStuff();
    profit(?)
return(0)

wenn Sie an der Consumer-Klasse aussehen siehe unten:

pseudo code:

RenderConsumer::operator () ()
    while(true)
        try to dequeue from queue
        //digest any packet we get
        for each ( pixel in packet )
            computePrettyStuff()
        //we are now done with packet that we got
        this_thread::interruption_point();

Ich habe versucht, diese einfach zu machen und schnell zu verdauen, wir danken Ihnen für Ihre Zeit

Answer 1

#1. I would do this by counting the amount in the queue after each render. If it too high, then either

a. Dump the queue

b. Set a boolean variable to false That variable will be shared between the threads, and when the producer sees that it is false, it begins waiting on a condition variable. The consumer then notifies the producer when the queue is down to an acceptable level again.

#2. Probably not possible with join_all, as the postcondition to join_all is

Every thread in the group has terminated.

according to the reference.

It might however be possible, using barriers instead of join_all, but then you would have to find a way to provide them data, which would invariably end up needing some more shared variables.