问题标签 [tbb-flow-graph]

我在我的 Raspberry Pi 3 上使用 OpenCV，它有 4 个内核。现在它是用 PThreads 编译的。OpenMP 或 TBB 性能会更好吗？还是取决于？

我主要做颜色转换、中值模糊、级联跟踪器和中值流跟踪器之类的事情。

我问是因为编译每个都需要永远并且有可能破坏一切。是否可以在不影响当前安装的内容的情况下编译和使用不同版本的 OpenCV（如果重要，我正在使用 Python 绑定）？

我已经构建了一个tbb::flow::graph由几个function_node对象组成的。在执行期间，我将多条消息传递到图表中（从 ~10 到 ~100000）。有时其中一个节点会引发异常。如果是这种情况，整个图表的执行将被取消，这意味着所有消息都将被丢弃。但是，我的消息是相互独立的，我不希望它们的执行被停止。

我可以直接在节点内捕获异常，但是当这种情况发生时，消息的进一步处理将没有意义。

所以我的问题是：如何在不取消执行图表中已经存在的其他消息的情况下从图表中取消或删除一条消息？

我正在学习使用英特尔 TBB 库，但遇到了一个奇怪的错误。我的源节点使用 fstream 从文件中读取数据，但是如果我尝试在类析构函数中关闭 fstream，则程序段错误。有谁知道为什么在使用英特尔 TBB 时不能在源节点类的析构函数中关闭文件流？还有什么是修复，所以我可以在完成读取后正确关闭文件？

使用 TBB，您可以创建一个不错的 DAG 任务，并且它可以自动并行运行它们。文档中的示例：

这很好用，但是它假设我有一些众所周知的根节点并且所有节点都是该节点的依赖项。如果我有一些可能有多个根节点的更通用的网络怎么办？

我希望这个例子很清楚——基本上我有很多任务，但它们之间的依赖关系是动态的，所以它们最终可能根本不相互依赖。我该如何对 TBB 说：“好的，我希望所有这些任务都运行。”

（显然我可以手动计算每个任务的依赖项数量，但我问的是 TBB 是否已经这样做了。）

编辑：要清楚，我问是否有自动启动所有根节点的功能。显然我可以手动完成 - 这就是上面的例子！

我正处于一个项目的开始阶段，我计划使用英特尔线程构建模块库，特别是 Flow Graph 部分。

在这方面我有两个问题：

1. 是否可以有具有异步输入/输出关系的节点？例如，一个特殊的缓冲区节点，它将接受一些数据输入，并偶尔提供一些输出（例如计算的统计信息）

2. 是否可以让节点向后续节点发送不同的消息？换句话说，不是一个简单的广播。

我有一个需要处理的文件来源。从每个文件中，我的代码生成可变数量的数据对象，我们称它为 N。我有 K 个处理对象，可用于处理 N 个数据对象。

我正在考虑使用 Tbb:dataflow 执行以下操作：

1. 创建一个并发K的function_node并将我的K个处理对象放入concurrent_queue。
2. 使用 input_node 读取文件，生成 N 个数据对象，并将每个数据对象 try_put 放入 function_node。
3. function_node 主体将处理对象出列，使用它来处理数据对象，然后在完成后将处理对象返回给 concurrent_queue。

我能想到的另一种方式可能是这样的：

1. 创建一个具有串行并发性的 function_node。
2. 使用 input_node 读取文件，生成 N 个数据对象，将数据对象放入一个集合并发送到 function_node。
3. 在 function_node 处，将 N 个对象划分为 K 个范围，并使用 K 个处理对象中的每一个来同时处理每个范围 - 不确定是否可以为此目的自定义 parallel_for。

第一种方法的优点可能是延迟较低，因为我可以在数据对象生成的那一刻开始通过数据流发送数据对象，而不必等待所有 N 个数据对象都生成。

您认为并行处理此处理的最佳方法是什么？

我正在开发一个使用 tbb::flow_graph 构建的图像处理应用程序。输入来自视频文件或相机。每个图像处理节点都包装在一个 multifunction_node 中（我需要 multifunction_node 有选择性地停止传播图形消息的能力）。目前我在将每个输入帧输入根节点后使用 graph.wait_for_all() ，但我希望能够利用管道并行性。即，如果节点 A 连接到节点 B，我想让节点 A 在完成生成其输出后开始处理其下一个输入，而不是等待 B 完成。

您能否提供有关如何有效且惯用地执行此操作的提示？我是 TBB 的新手，我觉得我可能遗漏了一些明显的东西。

I have a graph that has a few endpoints: f0(g(x)) and f1(g(x)). I could make a graph with an edge from g to f0 and g to f1, but if I do wait_for_all() it'll calculate both f0 and f1. But sometimes I only want to know f0(x) and other times I want f1(x), and sometimes I want to know both. Assuming g, f0, and f1 are all expensive to calculate, I'd like to be able to build a graph and call y0 = f0.run_and_wait() and then earlier, later, or at about the same time call y1 = f1.run_and_wait().

One approach is to not use a tbb flow graph and instead have f0 and f1 both call g, but that means two calls to g. Another approach is to have g do internal caching, but then if both calls to g happen at the same time, either both threads do the work or one thread blocks while the other does work. My understanding is that that goes against tbb's notion of non-blocking tasks.

I think maybe there's a way to use async_node to allow one thread to block on g, but that feels like a kludge.

Is there a tbb way to have nodes pull from their parent nodes on demand?

I'm new to the Intel Threading Building Blocks and playing with the flow graph component. So far, its worked mostly well. My messages between nodes are shared_ptr types so they are copy-constructble, lightweight, and the underlying resource is disposed of at the end of a graph cycle...

Except for messages that originate from my input_node. input_node is designed so that it holds a copy of its last output value. This means that the any resource held by the value output by an input_node won't be released until the input_node generates its next output.

This seems awkward/inconsistent with the rest of the API. Any thoughts on how to deal with it? I guess I could write my own node, but I'd rather not. Should I just use try_put? If so, how do I let the graph know when I'm done providing inputs, so that wait_for_all doesn't conclude early?

我正在尝试从 https://software.intel.com/content/www/us/en/develop/blogs/a-feature-detection-example-using-the-intel-threading-building-blocks修改此示例-flow-graph.html

这个想法是我有一个应用于每个输入的“预处理”函数，以及一个应用于每对预处理输入的“处理”函数，扫描流。在我的示例中，我们最终只是计算了连续平方数之间的差异。

我下面的例子不起作用。我相信这是因为缓冲区在开始时是空的。在博客示例中，它们会在某个时候填充缓冲区。打电话buffer.try_put(0)似乎并不能解决我的问题。我错过了什么？还有什么更好的方法可以让流程自然地工作，简单地忽略由于缓冲区为空而无法完全处理的第一个元素？