Como: Podem ser combinado para melhorar o desempenho do uso
Este exemplo mostra como usar o Concurrency::combinable classe para calcular a soma dos números em um std::array objeto são prime. O combinable classe melhora o desempenho eliminando o estado compartilhado.
Exemplo
O exemplo a seguir usa a std::accumulate a função para calcular a soma dos elementos em uma matriz são prime. Neste exemplo, a é um array objeto e o is_prime função determina se o seu valor de entrada é "Prime".
prime_sum = accumulate(a.begin(), a.end(), 0, [&](int acc, int i) {
return acc + (is_prime(i) ? i : 0);
});
O exemplo a seguir mostra uma maneira ingênuos paralelizar o exemplo anterior. Este exemplo usa a Concurrency::parallel_for_each algoritmo para processar a matriz em paralelo e uma Concurrency::critical_section o objeto para sincronizar o acesso para o prime_sum variável. Este exemplo não é dimensionado, porque cada segmento deve aguardar o recurso compartilhado se torne disponível.
critical_section cs;
prime_sum = 0;
parallel_for_each(a.begin(), a.end(), [&](int i) {
cs.lock();
prime_sum += (is_prime(i) ? i : 0);
cs.unlock();
});
O exemplo a seguir utiliza um combinable o objeto para melhorar o desempenho do exemplo anterior. Este exemplo elimina a necessidade de objetos de sincronização; Ele pode ser expandido porque o combinable objeto permite que cada thread executar sua tarefa independentemente.
A combinable objeto é geralmente usado em duas etapas. Primeiro, produza uma série de computações refinadas, realizando o trabalho em paralelo. Em seguida, combinar (ou reduzir) os cálculos em um resultado final. Este exemplo usa a Concurrency::combinable::local método para obter uma referência à soma de local. Depois ele usa o Concurrency::combinable::combine método e um std::plus o objeto para combinar as computações locais em que o resultado final.
combinable<int> sum;
parallel_for_each(a.begin(), a.end(), [&](int i) {
sum.local() += (is_prime(i) ? i : 0);
});
prime_sum = sum.combine(plus<int>());
O exemplo a seguir completo calcula a soma dos números primos tanto de serialmente e em paralelo. O exemplo imprime no console, o tempo necessário para executar ambas as computações.
// parallel-sum-of-primes.cpp
// compile with: /EHsc
#include <windows.h>
#include <ppl.h>
#include <array>
#include <numeric>
#include <iostream>
using namespace Concurrency;
using namespace std;
// Calls the provided work function and returns the number of milliseconds
// that it takes to call that function.
template <class Function>
__int64 time_call(Function&& f)
{
__int64 begin = GetTickCount();
f();
return GetTickCount() - begin;
}
// Determines whether the input value is prime.
bool is_prime(int n)
{
if (n < 2)
return false;
for (int i = 2; i < n; ++i)
{
if ((n % i) == 0)
return false;
}
return true;
}
int wmain()
{
// Create an array object that contains 200000 integers.
array<int, 200000> a;
// Initialize the array such that a[i] == i.
int n = 0;
generate(a.begin(), a.end(), [&] {
return n++;
});
int prime_sum;
__int64 elapsed;
// Compute the sum of the numbers in the array that are prime.
elapsed = time_call([&] {
prime_sum = accumulate(a.begin(), a.end(), 0, [&](int acc, int i) {
return acc + (is_prime(i) ? i : 0);
});
});
wcout << prime_sum << endl;
wcout << L"serial time: " << elapsed << L" ms" << endl << endl;
// Now perform the same task in parallel.
elapsed = time_call([&] {
combinable<int> sum;
parallel_for_each(a.begin(), a.end(), [&](int i) {
sum.local() += (is_prime(i) ? i : 0);
});
prime_sum = sum.combine(plus<int>());
});
wcout << prime_sum << endl;
wcout << L"parallel time: " << elapsed << L" ms" << endl << endl;
}
A saída de exemplo a seguir é de um computador que possui quatro processadores.
1709600813
serial time: 6178 ms
1709600813
parallel time: 1638 ms
Compilando o código
Para compilar o código, copiá-lo e colá-lo em um Visual Studio do projeto, ou colá-lo em um arquivo que é chamado paralelo soma de primes.cpp e, em seguida, execute o seguinte comando um Visual Studio janela do Prompt de comando.
cl.exe /EHsc parallel-sum-of-primes.cpp