Intel® oneAPI Threading Building Blocks Developer Guide and API Reference
overwrite_node
[flow_graph.overwrite_node]
A node that is a buffer of a single item that can be overwritten.
// Defined in header <oneapi/tbb/flow_graph.h>
namespace oneapi {
namespace tbb {
namespace flow {
template<typename T>
class overwrite_node : public graph_node, public receiver<T>, public sender<T> {
public:
explicit overwrite_node( graph &g );
overwrite_node( const overwrite_node &src );
~overwrite_node();
// Preview feature: Helper Functions for Expressing Graphs
explicit overwrite_node(decltype(follows(...)));
explicit overwrite_node(decltype(precedes(...)));
bool try_put( const T &v );
bool try_get( T &v );
// Preview feature: Waiting for Single Message
bool try_put_and_wait( const T &v );
bool is_valid( );
void clear( );
};
} // namespace flow
} // namespace tbb
} // namespace oneapiRequirements:
The type T must meet the DefaultConstructible requirements from [defaultconstructible] and CopyAssignable requirements from [copyassignable] ISO C++ Standard sections.
This type of node buffers a single item of type T. The value is initially invalid. Gets from the node are non-destructive.
overwrite_node is a graph_node, receiver<T> and sender<T>.
overwrite_node has a buffering and broadcast-pushproperties.
overwrite_node allows overwriting its single item buffer.
Member functions
explicitoverwrite_node(graph&g)
Constructs an object of type overwrite_node that belongs to the graph g with an invalid internal buffer item.
overwrite_node(constoverwrite_node&src)
Constructs an object of type overwrite_node that belongs to the graph g with an invalid internal buffer item. The buffered value and list of successors and predecessors are not copied from src.
~overwrite_node()
Destroys the overwrite_node.
booltry_put(constT&v)
Stores v in the internal single item buffer and calls try_put(v) on all successors.
Returns: true
booltry_get(T&v)
If the internal buffer is valid, assigns the value to v.
Returns:true if v is assigned to; false, otherwise.
boolis_valid()
Returns: true if the buffer holds a valid value; false, otherwise.
voidclear()
Invalidates the value held in the buffer.
Examples
The example demonstrates overwrite_node as a single-value storage that might be updated. Data can be accessed with direct try_get() call.
#include "oneapi/tbb/flow_graph.h"
int main() {
const int data_limit = 20;
int count = 0;
oneapi::tbb::flow::graph g;
oneapi::tbb::flow::function_node< int, int > data_set_preparation(g,
oneapi::tbb::flow::unlimited, []( int data ) {
printf("Prepare large data set and keep it inside node storage\n");
return data;
});
oneapi::tbb::flow::overwrite_node< int > overwrite_storage(g);
oneapi::tbb::flow::input_node< int > data_generator(g,
[&]( oneapi::tbb::flow_control& fc ) -> int {
if ( count < data_limit ) {
return ++count;
}
fc.stop();
return {};
});
oneapi::tbb::flow::function_node< int > process(g, oneapi::tbb::flow::unlimited,
[&]( const int& data) {
int data_from_storage = 0;
overwrite_storage.try_get(data_from_storage);
printf("Data from a storage: %d\n", data_from_storage);
printf("Data to process: %d\n", data);
});
oneapi::tbb::flow::make_edge(data_set_preparation, overwrite_storage);
oneapi::tbb::flow::make_edge(data_generator, process);
data_set_preparation.try_put(1);
data_generator.activate();
g.wait_for_all();
return 0;
}overwrite_node supports reserving join_node as its successor. See the example in the example section of write_once_node.
Preview Features
The following preview features extend the overwrite_node API:
Helper Functions for Expressing Graphs - allows overwrite_node to be constructed as a successor or a predecessor of the set of nodes.
Waiting for Single Message in Flow Graph - allows to put messages to overwrite_node and wait for all related work to complete.