Porady: wykonywanie mapowania i zmniejszanie operacji wykonywane równolegle
W tym przykładzie pokazano, jak używać algorytmów concurrency::p arallel_transform i concurrency::p arallel_reduce oraz klasy concurrency::concurrent_unordered_map w celu zliczenia wystąpień wyrazów w plikach.
Operacja mapy stosuje funkcję do każdej wartości w sekwencji. Operacja redukcji łączy elementy sekwencji w jedną wartość. Możesz użyć standardowej biblioteki C++ std::transform i std::accumulate , aby wykonywać operacje mapowania i redukcji. Jednak w celu zwiększenia wydajności wielu problemów można użyć algorytmu parallel_transform
do równoległego wykonania operacji mapy i parallel_reduce
algorytmu w celu równoległego wykonania operacji redukcji. W niektórych przypadkach można użyć concurrent_unordered_map
polecenia , aby wykonać mapę i zmniejszyć w jednej operacji.
Przykład
Poniższy przykład zlicza wystąpienia wyrazów w plikach. Używa metody std::vector do reprezentowania zawartości dwóch plików. Operacja mapy oblicza wystąpienia każdego słowa w każdym wektorze. Operacja redukcji gromadzi liczby wyrazów w obu wektorach.
// parallel-map-reduce.cpp
// compile with: /EHsc
#include <ppl.h>
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#include <numeric>
#include <unordered_map>
#include <windows.h>
using namespace concurrency;
using namespace std;
class MapFunc
{
public:
unordered_map<wstring, size_t> operator()(vector<wstring>& elements) const
{
unordered_map<wstring, size_t> m;
for_each(begin(elements), end(elements), [&m](const wstring& elem)
{
m[elem]++;
});
return m;
}
};
struct ReduceFunc : binary_function<unordered_map<wstring, size_t>,
unordered_map<wstring, size_t>, unordered_map<wstring, size_t>>
{
unordered_map<wstring, size_t> operator() (
const unordered_map<wstring, size_t>& x,
const unordered_map<wstring, size_t>& y) const
{
unordered_map<wstring, size_t> ret(x);
for_each(begin(y), end(y), [&ret](const pair<wstring, size_t>& pr) {
auto key = pr.first;
auto val = pr.second;
ret[key] += val;
});
return ret;
}
};
int wmain()
{
// File 1
vector<wstring> v1 {
L"word1", // 1
L"word1", // 1
L"word2",
L"word3",
L"word4"
};
// File 2
vector<wstring> v2 {
L"word5",
L"word6",
L"word7",
L"word8",
L"word1" // 3
};
vector<vector<wstring>> v { v1, v2 };
vector<unordered_map<wstring, size_t>> map(v.size());
// The Map operation
parallel_transform(begin(v), end(v), begin(map), MapFunc());
// The Reduce operation
unordered_map<wstring, size_t> result = parallel_reduce(
begin(map), end(map), unordered_map<wstring, size_t>(), ReduceFunc());
wcout << L"\"word1\" occurs " << result.at(L"word1") << L" times. " << endl;
}
/* Output:
"word1" occurs 3 times.
*/
Kompilowanie kodu
Aby skompilować kod, skopiuj go, a następnie wklej go w projekcie programu Visual Studio lub wklej go w pliku o nazwie parallel-map-reduce.cpp
, a następnie uruchom następujące polecenie w oknie wiersza polecenia programu Visual Studio.
cl.exe /EHsc parallel-map-reduce.cpp
Niezawodne programowanie
W tym przykładzie możesz użyć klasy zdefiniowanej concurrent_unordered_map
w pliku concurrent_unordered_map.h, aby wykonać mapę i zmniejszyć liczbę operacji.
// File 1
vector<wstring> v1 {
L"word1", // 1
L"word1", // 2
L"word2",
L"word3",
L"word4",
};
// File 2
vector<wstring> v2 {
L"word5",
L"word6",
L"word7",
L"word8",
L"word1", // 3
};
vector<vector<wstring>> v { v1, v2 };
concurrent_unordered_map<wstring, size_t> result;
for_each(begin(v), end(v), [&result](const vector<wstring>& words) {
parallel_for_each(begin(words), end(words), [&result](const wstring& word) {
InterlockedIncrement(&result[word]);
});
});
wcout << L"\"word1\" occurs " << result.at(L"word1") << L" times. " << endl;
/* Output:
"word1" occurs 3 times.
*/
Zazwyczaj równoległe są tylko zewnętrzne lub wewnętrzne pętle. Zrównaj pętlę wewnętrzną, jeśli masz stosunkowo niewiele plików, a każdy plik zawiera wiele słów. Zrównanie pętli zewnętrznej, jeśli masz stosunkowo wiele plików, a każdy plik zawiera kilka słów.
Zobacz też
Algorytmy równoległe
parallel_transform, funkcja
parallel_reduce, funkcja
concurrent_unordered_map, klasa