Commit: ed8c28789540c0e9f712bb34383bf6db22ed694b - parallel_sort (hg)

A simple parallel sort as a demonstration of how easy (and fast) this is in C++

Commit MetaInfo

• Revisión: ed8c28789540c0e9f712bb34383bf6db22ed694b (tree)
• Tiempo: 2018-12-16 15:54:51
• Autor: Eric Hopper <hopper@omni...>
• Commiter: Eric Hopper

Log Message

Switched to using raw arrays instead of vectors. <obj size

I didn't need any of the nice things vectors give you, no resizing
or anything. The executable shrank quite significantly, even
though I'm still using a deque.

Cambiar Resumen

• modified: mysort.cpp

Diferencia incremental

diff -r e36b2c2fcb58 -r ed8c28789540 mysort.cpp
--- a/mysort.cpp	Wed Dec 12 10:20:17 2018 -0800
+++ b/mysort.cpp	Sat Dec 15 22:54:51 2018 -0800
@@ -4,11 +4,12 @@
 #include <deque>
 #include <random>
 #include <utility>
+#include <memory>
 #include <cstdint>
 //#include <fstream>
 
-using vecsize_t = ::std::vector<::std::uint32_t>::size_type;
-using veciter_t = ::std::vector<::std::uint32_t>::iterator;
+using vecsize_t = ::std::uint64_t;
+using veciter_t = ::std::uint32_t *;
 
 void gen_and_sort_section(const veciter_t &begin, const veciter_t &end, int seed)
 {
@@ -58,22 +59,25 @@
 
 int main()
 {
-   using ::std::vector;
    using ::std::thread;
+   using ::std::unique_ptr;
+   using ::std::make_unique;
+   using ::std::uint32_t;
 
    constexpr auto size = 1ULL << 31;
-   ::std::vector<::std::uint32_t> huge_array(size);
+   auto huge_array = make_unique<uint32_t[]>(size);
    const int cpucount = ::std::max(thread::hardware_concurrency() / 2, 1U);
    const int sections = cpucount;
-   vector<decltype(huge_array.begin())> partitions(sections + 1);
+   const int secmarkers = sections + 1;
+   auto partitions = make_unique<veciter_t[]>(secmarkers);
 
-   partitions[0] = huge_array.begin();
-   for (unsigned int i = 1; i < partitions.size(); ++i) {
+   partitions[0] = &(huge_array[0]);
+   for (int i = 1; i < secmarkers; ++i) {
       auto const prev_part = partitions[i - 1];
-      auto const remaining = partitions.size() - i;
-      partitions[i] = prev_part + (huge_array.end() - prev_part) / remaining;
+      auto const remaining = secmarkers - i;
+      partitions[i] = prev_part + (&(huge_array[size]) - prev_part) / remaining;
    }
-   if (partitions[partitions.size() - 1] != huge_array.end()) {
+   if (partitions[secmarkers - 1] != &(huge_array[size])) {
       return 1;
    }