Question

我正在研究一种用C ++创建应用程序的架构，以便在不同的内核中同时处理多个输入。每个输入同时在单个核心中处理。核心上的每个进程，相同的过滤器都将通过处理。例如：filter1.apply（），filter2.apply（）和filter3.apply（）。针对4个输入的4个核心说明了这些过程，如下所示：

[core 1]   [core 2]    [core 3]   [core 4]
   |          |            |         |     
   V          V            V         V
  input1     input2      input3     input4
   |          |            |         |    
   V          V            V         V 
 filter1    filter1     filter1    filter1
   |          |            |         |    
   V          V            V         V 
 filter2    filter2     filter2    filter2
   |          |            |         |    
   V          V            V         V 
 filter3    filter3     filter3    filter3
   |          |            |         |    
   V          V            V         V 
 output1   output2      output3    output4

我不知道哪种架构或设计模式适合这种情况。如果你给我一些文物（文件或样本申请）以便进一步阅读，那就太好了。

提前致谢。

Answer 1

通常，线程池用于实现此类设计。它们几乎无限扩展以用于独立过程。您可以在TBB和PPL中找到简单的实现。它们提供许多标准算法和容器的并发相关版本。例如，在这个示例中，我使用了concurrent_vector，它是一个类似vector的容器，它可以从多个线程中同时安全地进行变异，而parallel_for_each则在许多线程上运行线程一次。

concurrent_vector<output> outputs;
std::vector<input> inputs;
parallel_for_each(inputs.begin(), inputs.end(), [](input& input) {
    outputs.push_back(filter3(filter2(filter1(input))));
});

Answer 2

我认为“策略方法”很有帮助。在每个核心中，将每个过滤器作为对象放入向量，如：

std::vector<filter> filters;

然后

std::for_each(filters.begin(), filters.end(), [input&](f&){f.apply(input);});

====================

我们通过过滤而不是输入进行迭代。所以我们可以在运行时添加/ del过滤。

像：

class YourCore {
public:
    void add_filter(const filter& f) {m_filters.add(f);}
    // void del_filter(int index);
    // void del_filter(by name or UID, so change vector to map or unordered_map);
private:
    std::vector<filter> m_filters;
};

哪种架构或设计模式适合此应用？

2 个答案: