Multithreading usando a biblioteca boost

Question

deseja chamar simultaneamente uma função várias vezes. Eu gostaria de usar tópicos para chamar uma função que irá utilizar a capacidade máquinas ao máximo. Esta é uma máquina de 8 núcleos, e minha exigência é a utilização do CPU da máquina de 10% a 100% ou mais.

Minha exigência é usar a classe boost. Existe alguma maneira eu posso fazer isso usando o fio impulso ou threadpool biblioteca? Ou alguma outra maneira de fazê-lo?

Além disso, se eu tiver que chamar várias funções com parâmetros diferentes de cada vez (com segmentos separados), qual é a melhor maneira de fazer isso? [Usando o impulso ou não usando boost] e como?

#include <iostream>
#include <fstream>
#include <string.h>
#include <time.h>
#include <boost/thread/mutex.hpp>
#include <boost/bind.hpp>

using namespace std;
using boost::mutex;
using boost::thread;

int threadedAPI1( );
int threadedAPI2( );
int threadedAPI3( );
int threadedAPI4( );

int threadedAPI1( ) {
    cout << "Thread0" << endl;
}


int threadedAPI2( ) {
    cout << "Thread1" << endl;
}

int threadedAPI3( ) {
    cout << "Thread2" << endl;
}

int threadedAPI4( ) {
    cout << "Thread3" << endl;
}

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

    boost::threadpool::thread_pool<> threads(4);
    // start a new thread that calls the "threadLockedAPI" function
    threads.schedule(boost::bind(&threadedAPI1,0));
    threads.schedule(boost::bind(&threadedAPI2,1));
    threads.schedule(boost::bind(&threadedAPI3,2));
    threads.schedule(boost::bind(&threadedAPI4,3));
    // wait for the thread to finish
    threads.wait();

    return 0;
}

A descrição acima não está funcionando e eu não tenho certeza por quê? : - (

Answer 1

Eu sugiro que você leia-se sobre a documentação para as funções que você usa. De seu comentário em resposta de James Hopkin, parece que você não sabe o que boost :: bind faz, mas simplesmente copiar-colar o código.

boost :: bind tem uma função (chamemos-lhe f) e, opcionalmente, uma série de parâmetros, e retorna uma função que, quando chamada, chamadas de f com os parâmetros especificados.

Isto é, boost::bind(threadedAPI1, 0)() (criando uma função que não recebe argumentos e pede threadedAPI1 () com o argumento 0, e em seguida, chamar que) é equivalente a threadedAPI1(0).

Uma vez que suas funções threadedAPI realmente não tomar quaisquer parâmetros, você não pode passar quaisquer argumentos para eles. Isso é apenas C ++ fundamentais. Você não pode chamar threadedAPI1(0), mas apenas threadedAPI1(), e ainda quando você chamar a função, você tenta (via boost :: bind) para passar o inteiro 0 como um argumento.

Assim, a resposta simples para a pergunta é simplesmente definir threadedAPI1 da seguinte forma:

int threadedAPI1(int i);

No entanto, uma forma de evitar o impulso :: bind chamadas é chamar um functor em vez de uma função livre ao lançar a linha. Declarar uma classe algo como isto:

struct threadedAPI {
  threadedAPI(int i) : i(i) {} // A constructor taking the arguments you wish to pass to the thread, and saves them in the class instance.

  void operator()() { // The () operator is the function that is actually called when the thread starts, and because it is just a regular class member function, it can see the 'i' variable initialized by the constructor
    cout << "Thread" << i << endl; // No need to create 4 identical functions. We can just reuse this one, and pass a different `i` each time we call it.
  }
private:
  int i;
};

Finalmente, dependendo do que você precisa, fios lisos pode ser mais adequado do que um pool de threads. Em geral, um pool de threads funciona somente um número limitado de tópicos, por isso pode fila algumas tarefas até que um de seus tópicos concluir a execução. Destina-se principalmente para casos onde você tem muitas tarefas viveu-curtas.

Se você tem um número fixo de tarefas de maior duração, criando uma linha dedicada para cada um pode ser o caminho a percorrer.

Answer 2

Você está parâmetros de ligação para funções que não receber parâmetros:

int threadedAPI1( );

boost::bind(&threadedAPI1,0)

Basta passar a função diretamente se não há parâmetros:

threads.schedule(&threadedAPI1)

Answer 3

Se o seu interesse é em usar o seu processador de forma eficiente, então você pode querer considerar intels enfiar a construção de blocos de http://www.intel.com/cd/software/products/asmo-na/eng/294797.htm . Eu acredito que ele é projetado especificamente para utilizar processadores multi-core, enquanto impulsionar fios folhas controlar até o usuário (ou seja, TBB vai enfiar diferente em um quad core em comparação com um dual core).

Quanto ao seu código que você está funções que não usam parâmetros para um parâmetro obrigatório. Por quê? Você também pode querer verificar o código de retorno de programação.