Eu estou tentando acelerar um programa usando std :: async. Vamos dizer que eu tenho uma função

T* f (const T& t1, const T& t2, const T& t3)

Onde T é um tipo que é caro para copiar. Eu tenho várias chamadas independentes de f com diferentes argumentos e eu tento paralelizá-los com std :: async aproximadamente assim: (onde m_futures é um std :: vetor de futuros do tipo correto).

for (...) {
   m_futures.push_back (
       std::async(
           std::launch::async,
           f,
           a,b,c));
}

Eu observei que o código acima atrasa a execução do meu programa. Eu passei por ele com gdb e quando o futuro é criado, o construtor de cópia de T é chamado três vezes. Por que é que? Os argumentos a, b, c são heap alocados, mas talvez o compilador não saiba sobre isso? Posso explicá-lo de alguma forma?

É sempre o caso que std :: async cria cópias dos argumentos, mesmo se eles devem ser passados ​​por referência const? Posso evitar isso de alguma forma? Na minha mente ingênua, deve haver apenas um ponteiro passado para as invocações diferentes da função (que só lê a partir da memória de qualquer maneira). Eu estou usando o gcc-4.6.3 no Linux se isso é importante.