Czy algorytmy równoległe C++17 są już zaimplementowane?
Próbowałem bawić się nowymi funkcjami bibliotek równoległych zaproponowanymi w standardzie C++17, ale nie mogłem go uruchomić. Próbowałem kompilować z aktualnymi wersjami g++ 8.1.1
i clang++-6.0
i -std=c++17
, ale żadna z nich nie wspierała #include <execution>
, std::execution::par
albo coś podobnego.
Patrząc na cppreference dla algorytmów równoległych istnieje długa lista algorytmów, twierdząc
Specyfikacja techniczna zapewnia wersje równoległe z następujących 69 algorytmów z
algorithm
,numeric
orazmemory
: ( ... długa lista ...)
Co brzmi, jakby algorytmy były gotowe 'na papierze', ale jeszcze nie gotowe do użycia?
W to pytanie sprzed ponad roku odpowiedzi twierdzą, że te funkcje nie zostały jeszcze zaimplementowane. Ale do tej pory spodziewałbym się, że zobaczę jakąś implementację. Możemy już coś wykorzystać?
4 answers
Możesz polecić https://en.cppreference.com/w/cpp/compiler_support aby sprawdzić wszystkie C++
status implementacji funkcji. W Twoim przypadku po prostu wyszukaj "Standardization of Parallelism TS
", a znajdziesz tylko Kompilatory MSVC
i Intel C++
obsługujące tę funkcję.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2019-04-18 23:49:16
GCC 9 ma je, ale musisz zainstalować TBB osobno
W Ubuntu 19.10 wszystkie komponenty zostały w końcu wyrównane:- Gcc 9 jest domyślną wersją i minimalną wymaganą wersją dla TBB
TBB (Intel Thread Building Blocks) jest w 2019~U8-1, więc spełnia minimalne wymagania 2018
Więc możesz po prostu zrobić:
sudo apt install gcc libtbb-dev
g++ -ggdb3 -O3 -std=c++17 -Wall -Wextra -pedantic -o main.out main.cpp -ltbb
./main.out
I używać jako:
#include <execution>
#include <algorithm>
std::sort(std::execution::par_unseq, input.begin(), input.end());
Zob. również pełny zakres benchmarka poniżej.
GCC 9 i TBB 2018 są pierwszymi, które działają, jak wspomniano w Uwagach do wydania: https://gcc.gnu.org/gcc-9/changes.html
Parallel algorithms i
<execution>
(wymaga bloków budujących wątek 2018 lub nowszych).
Powiązane wątki:
- Jak zainstalować TBB ze źródła na Linuksie i sprawić, by działało
- problemy z połączeniem biblioteki INTEL TBB
Instalacja Ubuntu 18.04
Ubuntu 18.04 to trochę więcej zaangażowany:
- GCC 9 można uzyskać z godnego zaufania PPA , więc nie jest tak źle
- TBB jest w wersji 2017, która nie działa, i nie mogłem znaleźć godnego zaufania PPA dla niego. Kompilowanie ze źródła jest łatwe, ale nie ma celu instalacji, co jest denerwujące...
Oto w pełni zautomatyzowane testowane polecenia Dla Ubuntu 18.04:
# Install GCC 9
sudo add-apt-repository ppa:ubuntu-toolchain-r/test
sudo apt-get update
sudo apt-get install gcc-9 g++-9
# Compile libtbb from source.
sudo apt-get build-dep libtbb-dev
git clone https://github.com/intel/tbb
cd tbb
git checkout 2019_U9
make -j `nproc`
TBB="$(pwd)"
TBB_RELEASE="${TBB}/build/linux_intel64_gcc_cc7.4.0_libc2.27_kernel4.15.0_release"
# Use them to compile our test program.
g++-9 -ggdb3 -O3 -std=c++17 -Wall -Wextra -pedantic -I "${TBB}/include" -L
"${TBB_RELEASE}" -Wl,-rpath,"${TBB_RELEASE}" -o main.out main.cpp -ltbb
./main.out
Analiza programu testowego
Przetestowałem z tym programem, który porównuje prędkość sortowania równoległego i seryjnego.
Main.cpp
#include <algorithm>
#include <cassert>
#include <chrono>
#include <execution>
#include <random>
#include <iostream>
#include <vector>
int main(int argc, char **argv) {
using clk = std::chrono::high_resolution_clock;
decltype(clk::now()) start, end;
std::vector<unsigned long long> input_parallel, input_serial;
unsigned int seed;
unsigned long long n;
// CLI arguments;
std::uniform_int_distribution<uint64_t> zero_ull_max(0);
if (argc > 1) {
n = std::strtoll(argv[1], NULL, 0);
} else {
n = 10;
}
if (argc > 2) {
seed = std::stoi(argv[2]);
} else {
seed = std::random_device()();
}
std::mt19937 prng(seed);
for (unsigned long long i = 0; i < n; ++i) {
input_parallel.push_back(zero_ull_max(prng));
}
input_serial = input_parallel;
// Sort and time parallel.
start = clk::now();
std::sort(std::execution::par_unseq, input_parallel.begin(), input_parallel.end());
end = clk::now();
std::cout << "parallel " << std::chrono::duration<float>(end - start).count() << " s" << std::endl;
// Sort and time serial.
start = clk::now();
std::sort(std::execution::seq, input_serial.begin(), input_serial.end());
end = clk::now();
std::cout << "serial " << std::chrono::duration<float>(end - start).count() << " s" << std::endl;
assert(input_parallel == input_serial);
}
Na Ubuntu 19.10, Lenovo ThinkPad P51 laptop z procesorem: procesor Intel Core i7-7820HQ (4 rdzenie / 8 wątków, podstawa 2.90 GHz, 8 MB pamięci podręcznej), RAM: 2x Samsung M471a2k43bb1-CRC (2x 16gib, 2400 Mbps) typowe wyjście dla wejścia z 100 milionami liczb do posortowania:
./main.out 100000000
Było:
parallel 2.00886 s
serial 9.37583 s
Więc Wersja równoległa była około 4,5 razy szybsza! Zobacz także: co oznaczają terminy "CPU bound" i " I / O bound" wredny?
Możemy potwierdzić, że proces generuje wątki za pomocą strace
:
strace -f -s999 -v ./main.out 100000000 |& grep -E 'clone'
Który pokazuje kilka linii typu:
[pid 25774] clone(strace: Process 25788 attached
[pid 25774] <... clone resumed> child_stack=0x7fd8c57f4fb0, flags=CLONE_VM|CLONE_FS|CLONE_FILES|CLONE_SIGHAND|CLONE_THREAD|CLONE_SYSVSEM|CLONE_SETTLS|CLONE_PARENT_SETTID|CLONE_CHILD_CLEARTID, parent_tidptr=0x7fd8c57f59d0, tls=0x7fd8c57f5700, child_tidptr=0x7fd8c57f59d0) = 25788
Ponadto, jeśli skomentuję wersję seryjną i uruchamiam z:
time ./main.out 100000000
Dostaję:
real 0m5.135s
user 0m17.824s
sys 0m0.902s
Błąd wiadomości
Google, zindeksuj to proszę.
Jeśli nie masz zainstalowanego tbb, błąd jest następujący:
In file included from /usr/include/c++/9/pstl/parallel_backend.h:14,
from /usr/include/c++/9/pstl/algorithm_impl.h:25,
from /usr/include/c++/9/pstl/glue_execution_defs.h:52,
from /usr/include/c++/9/execution:32,
from parallel_sort.cpp:4:
/usr/include/c++/9/pstl/parallel_backend_tbb.h:19:10: fatal error: tbb/blocked_range.h: No such file or directory
19 | #include <tbb/blocked_range.h>
| ^~~~~~~~~~~~~~~~~~~~~
compilation terminated.
Widzimy więc, że <execution>
zależy od odinstalowanego komponentu TBB.
Jeśli TBB jest za stary, np. domyślny Ubuntu 18.04, to nie działa z:
#error Intel(R) Threading Building Blocks 2018 is required; older versions are not supported.
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2020-09-29 23:08:26
Intel wydał równoległą bibliotekę STL zgodną ze standardem C++17:
Jest to połączenie w GCC .
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2018-06-25 20:59:44
Gcc nie implementuje jeszcze paralelizmu TS (zobacz https://gcc.gnu.org/onlinedocs/libstdc++ / manual / status.html#status. iso.2017)
Jednak libstdc++ (z gcc) ma tryb eksperymentalny dla niektórych równoważnych algorytmów równoległych. Zobacz https://gcc.gnu.org/onlinedocs/libstdc++/manual/parallel_mode.html
Getting it to work:
Każde użycie funkcji równoległych wymaga dodatkowego kompilatora i wsparcie runtime, w szczególności wsparcie dla OpenMP. Dodawanie tego wsparcia nie jest to trudne: wystarczy skompilować aplikację z flagą kompilatora - fopenmp. Spowoduje to połączenie w libgomp, Bibliotece uruchomieniowej GNU Offloading i Multi Processing, której obecność jest obowiązkowa.
Przykład kodu
#include <vector>
#include <parallel/algorithm>
int main()
{
std::vector<int> v(100);
// ...
// Explicitly force a call to parallel sort.
__gnu_parallel::sort(v.begin(), v.end());
return 0;
}
Warning: date(): Invalid date.timezone value 'Europe/Kyiv', we selected the timezone 'UTC' for now. in /var/www/agent_stack/data/www/doraprojects.net/template/agent.layouts/content.php on line 54
2018-06-25 20:38:28