Estou tentando implementar um algoritmo paralelo usando tarefas dentro do OpenMP. O padrão de programação paralela é baseado na idéia de produtor-consumidor, mas como o processo do consumidor é mais lento que o produtor, eu quero usar alguns produtores e vários consumidores. A idéia principal é criar tantos segmentos de SO quanto os produtores e, em seguida, cada um deles criará tarefas a serem feitas em paralelo (pelos consumidores). Cada produtor será associado a um número proporcional de consumidores (por exemplo, numCheckers / numSeekers). Estou executando o algoritmo em um servidor Intel Dual-chip com 6 núcleos por chip. O fato é que quando eu uso apenas um produtor (buscador) e um número crescente de consumidores (damas) o desempenho decai muito rápido conforme o número de consumidores cresce (veja a tabela abaixo), embora o número correto de núcleos esteja funcionando 100%. Por outro lado, se eu aumentar o número de produtores, o tempo médio diminui ou pelo menos fica estável, mesmo com um número proporcional de consumidores. Parece-me que toda a melhoria é feita pela divisão do input entre os produtores, e as tarefas são apenas bugging. Mas, novamente, não tenho nenhuma explicação para o comportamento de um produtor. Estou faltando alguma coisa na lógica do OpenMP-Task? Estou fazendo algo errado?

-------------------------------------------------------------------------
|   producers   |   consumers   |   time        |
-------------------------------------------------------------------------
|       1       |       1       |   0.642935    |
|       1       |       2       |   3.004023    |
|       1       |       3       |   5.332524    |
|       1       |       4       |   7.222009    |
|       1       |       5       |   9.472093    |
|       1       |       6       |   10.372389   |
|       1       |       7       |   12.671839   |
|       1       |       8       |   14.631013   |
|       1       |       9       |   14.500603   |
|       1       |      10       |   18.034931   |
|       1       |      11       |   17.835978   |
-------------------------------------------------------------------------
|       2       |       2       |   0.357881    |
|       2       |       4       |   0.361383    |
|       2       |       6       |   0.362556    |
|       2       |       8       |   0.359722    |
|       2       |      10       |   0.358816    |
-------------------------------------------------------------------------

A seção principal do meu código é tão inativa:

int main( int argc, char** argv) {

  // ... process the input (read from file, etc...)

  const char *buffer_start[numSeekers];
  int buffer_len[numSeekers];

  //populate these arrays dividing the input
  //I need to do this because I need to overlap the buffers for
  //correctness, so I simple parallel-for it's not enough 

  //Here is where I create the producers
  int num = 0;
  #pragma omp parallel for num_threads(numSeekers) reduction(+:num)
  for (int i = 0; i < numSeekers; i++) {
      num += seek(buffer_start[i], buffer_len[i]);
  }

  return (int*)num;
}

int seek(const char* buffer, int n){

  int num = 0;

  //asign the same number of consumers for each producer 
  #pragma omp parallel num_threads(numCheckers/numSeekers) shared(num)
  {
    //only one time for every producer
    #pragma omp single
    {
      for(int pos = 0; pos < n; pos += STEP){
    if (condition(buffer[pos])){
      #pragma omp task shared(num)
      {
        //check() is a sequential function
        num += check(buffer[pos]);
      }
    }
      }
      #pragma omp taskwait
    }
  return num;
}