quali modelli di architettura o design sono adatti per questa applicazione?

Sto cercando un'architettura per la creazione di un'applicazione in C++ per elaborare più input contemporaneamente in diversi core. Ogni input viene elaborato in un singolo core contemporaneamente. Ciascuno dei processi su un core, gli stessi filtri saranno elaborati attraverso. Ad esempio: filter1.apply(), filter2.apply() e filter3.apply(). I processi sono illustrati per 4 core per 4 ingressi come qui sotto:quali modelli di architettura o design sono adatti per questa applicazione?

 
[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

poteva essere che l'architettura o design pattern è adatto a questo. Sarebbe fantastico se tu mi dessi alcuni artefatti (documenti o applicazione di esempio) per leggere oltre.

Grazie in anticipo.

fonte

2012-01-02 olidev

@Joachim: grazie per la tua edizione. In realtà, stavo migliorando anche io :) – olidev

Proprio come una nota a margine, sembra che potresti in qualche modo compilare la sequenza del filtro in un singolo filtro, quindi quella potrebbe essere una vittoria netta, dato che stai sempre facendo la stessa sequenza di cose - un po 'come le liste di visualizzazione in OpenGL. –

compilare i filtri in un singolo filtro non è bello perché l'ambito (numero di righe) di una funzione è molto grande. e mi piacerebbe che questa architettura in futuro fosse più flessibile nell'aggiunta di nuovi filtri. Ad esempio: vengono aggiunti il filtro 4 e il filtro 5, quindi ho semplicemente chiamato: filter1.apply(), filter2.apply(), filter3.apply(), filter4.apply() e filter5.apply(). – olidev

Solitamente i pool di thread vengono utilizzati per implementare tali progetti. Si ridimensionano virtualmente all'infinito per processi indipendenti. È possibile trovare semplici implementazioni in TBB e PPL. Offrono versioni relative alla concorrenza di numerosi algoritmi e contenitori standard. Ad esempio, in questo esempio ho usato concurrent_vector, che è un contenitore di tipo vector che può essere tranquillamente modificato da più thread contemporaneamente e parallel_for_each, che esegue la funzione su più thread contemporaneamente.

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

fonte

2012-01-02 13:23:38 Puppy

Solo per aggiungere qualcosa, se non sai a priori quante iterazioni o attività hai, TBB offre anche una bella funzione chiamata parallel_do che "cuoce fino a quando". – inf

dove posso trovare TBB? – olidev

Non sono sicuro se lo utilizzo perché l'input di questo filtro è l'output del filtro successivo. l'input è un array di immagini ma non è unione, possono essere di tipo: int, float o char. Non so se questo è adatto? – olidev

Penso che "metodo di strategia" sia utile. In ciascuna anima, mette ogni filtro come un oggetto da un vettore, come:

std::vector<filter> filters;

poi

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

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

Abbiamo iterato dal filtro, non immesso. Quindi possiamo aggiungere/del filtro in fase di runtime.

come:

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; 
};

fonte

2012-01-02 14:04:29

quali modelli di architettura o design sono adatti per questa applicazione?

risposta

Problemi correlati