Intel TBB computational Graph: Wie Eingabe Eingangswarteschlange Kapazität des Knotens

Question

Ich bin auf der Suche nach C++ Analog der .NET TPL Dataflow-Bibliothek.

In TPL Dataflow können Sie die Parallelitätsoptionen & Blockkapazität angeben. Wenn die Größe der Eingangswarteschlange des Blocks erreicht ist es Kapazität dann die Ausführung des Herstellers des entsprechenden Blocks aufgehängt ist:

var buffer = new BufferBlock<int>(new DataflowBlockOptions() { BoundedCapacity = 10 }); 

var producer = new Task(() => { 
    for (int i = 0; i < 1000; i++) { 
     buffer.Post(i); 
    } 
}); 

var fstAction = new TransformBlock<int, int>(async (i) => { 
    return i*i; 
}, MaxDegreeOfParallelism = 4, BoundedCapacity = 10); 

var sndAction = new ActionBlock<int>(async (i) => { 
    Thread.Sleep(5000); 
    Console.WriteLine(i); 
}, MaxDegreeOfParallelism = 4, BoundedCapacity = 10); 

buffer.LinkTo(fstAction, new DataflowLinkOptions() { PropagateCompletion = true }); 
fstAction.LinkTo(sndAction, new DataflowLinkOptions() { PropagateCompletion = true }); 

sndAction.Completition.Wait(); 

Und ich brauche eine ähnliche Funktionalität in C++. TBB scheint eine gute Wahl zu sein, aber ich kann nicht finden, wie man die Kapazität auf function_node/buffer_node spezifiziert. Hier ist ein ein Beispiel:

std::size_t exportConcurrency = 16; 
std::size_t uploadConcurrency = 16; 

flow::graph graph; 

std::size_t count = 1000; 
std::size_t idx = 0; 

flow::source_node<std::vector<std::string>> producerNode(graph, [&count, &idx](auto& out) { 
    out = { "0"s }; 
    return ++idx != count; 
}); 

flow::function_node<std::vector<std::string>, std::string> exportNode(graph, exportConcurrency, [](auto& ids) { 
    return "0"s; 
}); 

flow::function_node<std::string, std::string> uploadNode(graph, uploadConcurrency, [](auto& chunk) { 
    std::this_thread::sleep_for(5s); 
    return "0"s; 
}); 

flow::make_edge(producerNode, exportNode); 
flow::make_edge(exportNode, uploadNode); 

graph.wait_for_all(); 

Answer 1

One in der official docs finden, dass es drei empfohlene Wege zu limiting resource consumption, und einer von ihnen ist using limiter_node:

Eine Möglichkeit, den Ressourcenverbrauch zu begrenzen, ist zu Verwenden Sie limiter_node, um einen Grenzwert für die Anzahl der Nachrichten festzulegen, die durch einen bestimmten Punkt in Ihrem Diagramm fließen können.

Es ist nicht die genaue Sache, die Sie wollen, aber immer noch untersucht werden sollte. Auch ich konnte die concurrent queue classes Abschnitte finden, die mit begrenzter Kapazität mit set_capacity Methode verwendet werden können. Vielleicht kannst du es so schaffen. Hoffe das hilft.