From ea78847e002c2f0b6b3653539cb2b94580aea690 Mon Sep 17 00:00:00 2001 From: Thomas Nagler Date: Thu, 27 Jan 2022 20:51:57 +0100 Subject: [PATCH] aligned allocation of vectors (#15) * aligned allocator for vectors * custom new/delete for ThreadPool * comments * finalize * allow throwing ThreadPool::new --- docs/Doxyfile | 2 +- docs/annotated.html | 2 +- docs/classes.html | 2 +- .../classquickpool_1_1ThreadPool-members.html | 4 +- docs/classquickpool_1_1ThreadPool.html | 26 +- docs/files.html | 2 +- docs/functions.html | 8 +- docs/functions_func.html | 8 +- docs/graph_legend.html | 2 +- docs/hierarchy.html | 90 + docs/index.html | 22 +- docs/inherit_graph_0.map | 3 + docs/inherit_graph_0.md5 | 1 + docs/inherit_graph_0.png | Bin 0 -> 2765 bytes docs/inherit_graph_1.map | 5 + docs/inherit_graph_1.md5 | 1 + docs/inherit_graph_1.png | Bin 0 -> 7735 bytes docs/inherit_graph_2.map | 3 + docs/inherit_graph_2.md5 | 1 + docs/inherit_graph_2.png | Bin 0 -> 3605 bytes docs/inherit_graph_3.map | 3 + docs/inherit_graph_3.md5 | 1 + docs/inherit_graph_3.png | Bin 0 -> 1696 bytes docs/inherits.html | 104 + docs/namespacemembers.html | 2 +- docs/namespacemembers_func.html | 2 +- docs/namespacequickpool.html | 12 +- docs/namespacequickpool_1_1padding__impl.html | 104 + docs/namespaces.html | 2 +- docs/quickpool_8hpp_source.html | 1704 +++++++++-------- docs/search/all_3.js | 5 +- docs/search/all_4.js | 5 +- docs/search/all_5.js | 3 +- docs/search/all_6.js | 2 +- docs/search/all_7.js | 2 +- docs/search/all_8.html | 30 + docs/search/all_8.js | 4 + docs/search/all_9.html | 30 + docs/search/all_9.js | 4 + docs/search/all_a.html | 30 + docs/search/all_a.js | 4 + docs/search/classes_0.js | 2 +- docs/search/classes_1.html | 30 + docs/search/classes_1.js | 6 + docs/search/classes_2.html | 30 + docs/search/classes_2.js | 4 + docs/search/functions_0.js | 2 +- docs/search/functions_1.js | 2 +- docs/search/functions_2.js | 4 +- docs/search/functions_3.js | 5 +- docs/search/functions_4.js | 4 +- docs/search/functions_5.js | 2 +- docs/search/functions_6.js | 2 +- docs/search/functions_7.html | 30 + docs/search/functions_7.js | 4 + docs/search/functions_8.html | 30 + docs/search/functions_8.js | 4 + docs/search/namespaces_0.js | 2 +- docs/search/pages_0.js | 2 +- docs/search/searchdata.js | 4 +- ...ool_1_1padding__impl_1_1empty__struct.html | 88 + ...quickpool_1_1padding__impl_1_1padding.html | 112 ++ ...dding__impl_1_1padding__bytes-members.html | 88 + ...ol_1_1padding__impl_1_1padding__bytes.html | 140 ++ ...1padding__impl_1_1padding__coll__graph.map | 4 + ...1padding__impl_1_1padding__coll__graph.md5 | 1 + ...1padding__impl_1_1padding__coll__graph.png | Bin 0 -> 8925 bytes ...dding__impl_1_1padding__inherit__graph.map | 4 + ...dding__impl_1_1padding__inherit__graph.md5 | 1 + ...dding__impl_1_1padding__inherit__graph.png | Bin 0 -> 8925 bytes docs/test_8cpp_source.html | 646 +++---- quickpool.hpp | 213 ++- test.cpp | 6 +- 73 files changed, 2441 insertions(+), 1266 deletions(-) create mode 100644 docs/hierarchy.html create mode 100644 docs/inherit_graph_0.map create mode 100644 docs/inherit_graph_0.md5 create mode 100644 docs/inherit_graph_0.png create mode 100644 docs/inherit_graph_1.map create mode 100644 docs/inherit_graph_1.md5 create mode 100644 docs/inherit_graph_1.png create mode 100644 docs/inherit_graph_2.map create mode 100644 docs/inherit_graph_2.md5 create mode 100644 docs/inherit_graph_2.png create mode 100644 docs/inherit_graph_3.map create mode 100644 docs/inherit_graph_3.md5 create mode 100644 docs/inherit_graph_3.png create mode 100644 docs/inherits.html create mode 100644 docs/namespacequickpool_1_1padding__impl.html create mode 100644 docs/search/all_8.html create mode 100644 docs/search/all_8.js create mode 100644 docs/search/all_9.html create mode 100644 docs/search/all_9.js create mode 100644 docs/search/all_a.html create mode 100644 docs/search/all_a.js create mode 100644 docs/search/classes_1.html create mode 100644 docs/search/classes_1.js create mode 100644 docs/search/classes_2.html create mode 100644 docs/search/classes_2.js create mode 100644 docs/search/functions_7.html create mode 100644 docs/search/functions_7.js create mode 100644 docs/search/functions_8.html create mode 100644 docs/search/functions_8.js create mode 100644 docs/structquickpool_1_1padding__impl_1_1empty__struct.html create mode 100644 docs/structquickpool_1_1padding__impl_1_1padding.html create mode 100644 docs/structquickpool_1_1padding__impl_1_1padding__bytes-members.html create mode 100644 docs/structquickpool_1_1padding__impl_1_1padding__bytes.html create mode 100644 docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.map create mode 100644 docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.md5 create mode 100644 docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.png create mode 100644 docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.map create mode 100644 docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.md5 create mode 100644 docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.png diff --git a/docs/Doxyfile b/docs/Doxyfile index 58e9613..747874a 100644 --- a/docs/Doxyfile +++ b/docs/Doxyfile @@ -38,7 +38,7 @@ PROJECT_NAME = "quickpool" # could be handy for archiving the generated documentation or if some version # control system is used. -PROJECT_NUMBER = 1.3.0 +PROJECT_NUMBER = 1.4.0 # Using the PROJECT_BRIEF tag one can provide an optional one line description # for a project that appears at the top of each page and should give viewer a diff --git a/docs/annotated.html b/docs/annotated.html index 8721880..aa8f360 100644 --- a/docs/annotated.html +++ b/docs/annotated.html @@ -22,7 +22,7 @@
quickpool -  1.3.0 +  1.4.0
An easy-to-use, header-only work stealing thread pool in C++11
diff --git a/docs/classes.html b/docs/classes.html index b6f5ce3..03995e0 100644 --- a/docs/classes.html +++ b/docs/classes.html @@ -22,7 +22,7 @@
quickpool -  1.3.0 +  1.4.0
An easy-to-use, header-only work stealing thread pool in C++11
diff --git a/docs/classquickpool_1_1ThreadPool-members.html b/docs/classquickpool_1_1ThreadPool-members.html index 7cc3970..f583565 100644 --- a/docs/classquickpool_1_1ThreadPool-members.html +++ b/docs/classquickpool_1_1ThreadPool-members.html @@ -22,7 +22,7 @@
quickpool -  1.3.0 +  1.4.0
An easy-to-use, header-only work stealing thread pool in C++11
@@ -78,6 +78,8 @@ done() constquickpool::ThreadPoolinline get_active_threads() constquickpool::ThreadPoolinline global_instance()quickpool::ThreadPoolinlinestatic + operator delete(void *ptr)quickpool::ThreadPoolinlinestatic + operator new(size_t count) noexceptquickpool::ThreadPoolinlinestatic operator=(const ThreadPool &)=delete (defined in quickpool::ThreadPool)quickpool::ThreadPool operator=(ThreadPool &&other)=delete (defined in quickpool::ThreadPool)quickpool::ThreadPool parallel_for(int begin, int end, UnaryFunction f)quickpool::ThreadPoolinline diff --git a/docs/classquickpool_1_1ThreadPool.html b/docs/classquickpool_1_1ThreadPool.html index 043977a..8b6d3c5 100644 --- a/docs/classquickpool_1_1ThreadPool.html +++ b/docs/classquickpool_1_1ThreadPool.html @@ -22,7 +22,7 @@
quickpool -  1.3.0 +  1.4.0
An easy-to-use, header-only work stealing thread pool in C++11
@@ -135,11 +135,19 @@ static ThreadPool & global_instance ()  returns a reference to the global thread pool instance.
  + +static void * operator new (size_t count) noexcept + allocator respecting memory alignment.
+  + +static void operator delete (void *ptr) + deallocator respecting memory alignment.
+ 

Detailed Description

A work stealing thread pool.

-

Definition at line 678 of file quickpool.hpp.

+

Definition at line 756 of file quickpool.hpp.

Constructor & Destructor Documentation

◆ ThreadPool()

@@ -173,7 +181,7 @@

Definition at line 684 of file quickpool.hpp.

+

Definition at line 762 of file quickpool.hpp.

@@ -225,7 +233,7 @@

Returns
A std::future for the task. Call future.get() to retrieve the results at a later point in time (blocking).
-

Definition at line 760 of file quickpool.hpp.

+

Definition at line 838 of file quickpool.hpp.

@@ -282,7 +290,7 @@

Definition at line 781 of file quickpool.hpp.

+

Definition at line 859 of file quickpool.hpp.

@@ -332,7 +340,7 @@

Definition at line 803 of file quickpool.hpp.

+

Definition at line 881 of file quickpool.hpp.

@@ -381,7 +389,7 @@

Definition at line 746 of file quickpool.hpp.

+

Definition at line 824 of file quickpool.hpp.

@@ -417,7 +425,7 @@

Definition at line 718 of file quickpool.hpp.

+

Definition at line 796 of file quickpool.hpp.

@@ -453,7 +461,7 @@

Definition at line 814 of file quickpool.hpp.

+

Definition at line 892 of file quickpool.hpp.

diff --git a/docs/files.html b/docs/files.html index db59962..894448e 100644 --- a/docs/files.html +++ b/docs/files.html @@ -22,7 +22,7 @@
quickpool -  1.3.0 +  1.4.0
An easy-to-use, header-only work stealing thread pool in C++11
diff --git a/docs/functions.html b/docs/functions.html index 6eba2e7..7fd0019 100644 --- a/docs/functions.html +++ b/docs/functions.html @@ -22,7 +22,7 @@
quickpool -  1.3.0 +  1.4.0
An easy-to-use, header-only work stealing thread pool in C++11
@@ -76,6 +76,12 @@
  • global_instance() : quickpool::ThreadPool
    • +
  • operator delete() +: quickpool::ThreadPool +
    • +
  • operator new() +: quickpool::ThreadPool +
  • parallel_for() : quickpool::ThreadPool
    • diff --git a/docs/functions_func.html b/docs/functions_func.html index 7799571..127cf35 100644 --- a/docs/functions_func.html +++ b/docs/functions_func.html @@ -22,7 +22,7 @@
    quickpool -  1.3.0 +  1.4.0
    An easy-to-use, header-only work stealing thread pool in C++11
    @@ -76,6 +76,12 @@
  • global_instance() : quickpool::ThreadPool
    • +
  • operator delete() +: quickpool::ThreadPool +
    • +
  • operator new() +: quickpool::ThreadPool +
  • parallel_for() : quickpool::ThreadPool
    • diff --git a/docs/graph_legend.html b/docs/graph_legend.html index 024d85d..d1ddaaf 100644 --- a/docs/graph_legend.html +++ b/docs/graph_legend.html @@ -22,7 +22,7 @@
    quickpool -  1.3.0 +  1.4.0
    An easy-to-use, header-only work stealing thread pool in C++11
    diff --git a/docs/hierarchy.html b/docs/hierarchy.html new file mode 100644 index 0000000..0bb0081 --- /dev/null +++ b/docs/hierarchy.html @@ -0,0 +1,90 @@ + + + + + + + +quickpool: Class Hierarchy + + + + + + + + + +
    +
    + + + + + + +
    +
    quickpool +  1.3.0 +
    +
    An easy-to-use, header-only work stealing thread pool in C++11
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +
    +
    Class Hierarchy
    +
    +
    +
    +

    Go to the graphical class hierarchy

    +This inheritance list is sorted roughly, but not completely, alphabetically:
    +
    [detail level 12]
    + + + + + + +
     Cquickpool::padding_impl::empty_struct
     Cquickpool::padding_impl::padding_bytes< T, Align >
     Cquickpool::ThreadPoolA work stealing thread pool
     ▼Ctype
     Cquickpool::padding_impl::padding< T, 64 >
     Cquickpool::padding_impl::padding< T, Align >
    +
    +
    + +
    +Generated by   +doxygen + 1.8.17 +
    + + diff --git a/docs/index.html b/docs/index.html index bc1d4b7..f1a6d74 100644 --- a/docs/index.html +++ b/docs/index.html @@ -22,7 +22,7 @@
    quickpool -  1.3.0 +  1.4.0
    An easy-to-use, header-only work stealing thread pool in C++11
    @@ -158,16 +158,16 @@

    pool.parallel_for_each(x, [] (double& xx) {});
    -
    quickpool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction &&f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:954
    -
    quickpool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction &&f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:971
    -
    quickpool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously the global thread pool.
    Definition: quickpool.hpp:905
    -
    quickpool::ThreadPool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:781
    -
    quickpool::ThreadPool::wait
    void wait(size_t millis=0)
    waits for all jobs currently running on the thread pool. Has no effect when called from threads other...
    Definition: quickpool.hpp:814
    -
    quickpool::ThreadPool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:803
    -
    quickpool::wait
    void wait()
    waits for all jobs currently running on the global thread pool. Has no effect when not called from ma...
    Definition: quickpool.hpp:914
    -
    quickpool::ThreadPool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously on the global thread pool.
    Definition: quickpool.hpp:760
    -
    quickpool::ThreadPool::push
    void push(Function &&f, Args &&... args)
    pushes a job to the thread pool.
    Definition: quickpool.hpp:746
    -
    quickpool::push
    void push(Function &&f, Args &&... args)
    Free-standing functions (main API)
    Definition: quickpool.hpp:892
    +
    quickpool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction &&f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:1041
    +
    quickpool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction &&f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:1058
    +
    quickpool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously the global thread pool.
    Definition: quickpool.hpp:992
    +
    quickpool::ThreadPool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:859
    +
    quickpool::ThreadPool::wait
    void wait(size_t millis=0)
    waits for all jobs currently running on the thread pool. Has no effect when called from threads other...
    Definition: quickpool.hpp:892
    +
    quickpool::ThreadPool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:881
    +
    quickpool::wait
    void wait()
    waits for all jobs currently running on the global thread pool. Has no effect when not called from ma...
    Definition: quickpool.hpp:1001
    +
    quickpool::ThreadPool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously on the global thread pool.
    Definition: quickpool.hpp:838
    +
    quickpool::ThreadPool::push
    void push(Function &&f, Args &&... args)
    pushes a job to the thread pool.
    Definition: quickpool.hpp:824
    +
    quickpool::push
    void push(Function &&f, Args &&... args)
    Free-standing functions (main API)
    Definition: quickpool.hpp:979
    Generated by   diff --git a/docs/inherit_graph_0.map b/docs/inherit_graph_0.map new file mode 100644 index 0000000..b031d2e --- /dev/null +++ b/docs/inherit_graph_0.map @@ -0,0 +1,3 @@ + + + diff --git a/docs/inherit_graph_0.md5 b/docs/inherit_graph_0.md5 new file mode 100644 index 0000000..467724d --- /dev/null +++ b/docs/inherit_graph_0.md5 @@ -0,0 +1 @@ +5e585ddc5676707fe59173eee613189f \ No newline at end of file diff --git a/docs/inherit_graph_0.png b/docs/inherit_graph_0.png new file mode 100644 index 0000000000000000000000000000000000000000..f3c3508fbc7483c0682362956211d5973bd16b80 GIT binary patch literal 2765 zcmV;;3NrPHP)4hOD&>~p)Jr-lWjys6%#dz3fXjMbz#mG zUr;ogCNf8&^F8j%Ospspx0qm9rehiebRQ-}<4cH%Oni+mF-Cy`YZ(YAAP5?PXCD@B zY|HI!DWw-YzoZ}TdCob{zYh=ho^#Jb;E0I8VECRwnXeTv7`?D$WJm^QYKZh9~&D=YK0gkj52imfE>j0^@aK*?BFR|kW^0HsoisHi9$ zIda5i-J({jap}?}zQ5IK1;=q{X=wrA_$Ybt;sw&v)1lRB5gZ(h4I4J#<;#~2emgok z@WmHjV9}yQyj`!?W7n=-h>MGZQmMq$sZ&u}TFQ@UXlTHS6)O-D5`qst_yB9xtiki= z&t10LV=|dAY0@OYYcV|rg8>}JK_-(ytJPxf-o1Fcs?R>QXU?2)8hd-YeQfo5J@)L` zgM@?xD3wZl_~D1RaNz=PudS`c!i5X@`F{E3mqA;D4oET@jYjzS`Jtks0%y;j#qs0E zJ(@2iB?Wix+(B`1F{-Mn5E~ndl9CdeKK1qWm^*haCQh7)zyA6Qfq{X%Ejv3KKmGI* ztX3hoTdl$EE-GaqpK}t#rKUU1%ADrnaDk=gI;mw;j z`18*{@%!(;BQGzHA1fBy{=_~vHy0+83H9~$SiO2RQc_a*UjU=gh@hY#R904^sHkXg zH;ZIPettgn(JV+sMFjz%r%#{qZI>=xA^_Cb*hoY~DwT>ZUcAWLEfxy_pyuXgA|jeT zeLCgjAAAd|oj~=DU%1Q!2RaI5I z?ZJZw1c3hi_g_)Fy;fInrl&6sA3jV*qmhWjW9v%n?e)gQ#875tCV&0>`Evq5R;!iD z%gb%X5)oa#eA%JR6P)B%fyZ}7tJR9Yz(9nAgz#-Tovz>WRaaMI#E212=lJcn-w+TG zfV8xZfXdQCC-oo}M0LWo4nOs|$d5Y+Z@H zJE&ADw70k0tPeez&s{uDMx9QFS+i#0yYIe3V`C%CW;1r~+-cKCuh-+)v14dyX+cd* z4YqIJE;wI!csL9O1JQ z%9SfX=!PwtE+>>V!`*{e~-k(L`;}4LDb$CVjCD| zdOABh(bLm|pr9a(8Z`=KWo5|9%5pijuEgFQCQX`znKNf%)22-WGM~E)$Oa}qKOgPw z?a=9TFc=J2y?V8cegFRbXliPLN~MCqV8EAOe(7|+6DLj}IyxE)7A!zyWF&6izK!_! zcw6Bz8FF%RkdTmoIdkUlk2U~UzkWS-@7|4x6DQ*2$&)B9F2?)szt3w`C=~eQlTQ#E z8w-_6h1}d+oA2Vx-XDbYXfzsRWMp9Z^5sw}mDs#_vqNmeVk>5Mm;C&Ew6wH9r_*84 zqD5G?Y#9Jx)TmJ&&Fd0wEHGWBuC8uC7rpKf6B9#!{PD-2`xQcJdfcVBxR`>2g9mIr zXB!wvoWL-oLw z1Y~Ar4vKHD+!;edLv2nG29vvY@A|~A5K_}4#<+3gaO%`4pZFdYcgCSqnZgjp>&eIx zh2bh*PsXycGJNyRH{Nz5d8SR9=JA=mlze%^$FO)zGlmC){+QP5_1L_5Gveanpin3f z6%~c+*RLZpGZSjH8bLupSigQfdU|?n#yBg(vPbMxq`kcz>FMc+h={xmFk{9HWM^k1Iy%}$cX@d^?HO@H#0ei4qeN$!s=LYilcQ*|LSEOqoL6-Q8Z(7#kZ)$BrH2`?s~Vky5Fot5>h` zZCkc%q0c}6Tr{SSA3vs%BS+HJt5>PBvy-k}yGB3!@B?qR_tmQ}G&Gb-OG~M%tBZ)l ztErYOSwgdC&!&eDA5wF3GaWs8l+K<#E9k=&oW1n+NirTfbcnw$DJdb2@SlTxXq`}gmAO=Dj_ytK45TD58w5fQz5^@_%g z8%Jl(oDuyFX0w?B0|R-z_6Q~8-o1Nm+MFe$SSg=3lF=t?#@=&c0PyqkLqI@)O>wNB zpPx;Y58%8E%N=?vXjCc{IF19yaTqaT1YW#&f$Hk&LDjf%<3^l5eHzc6Jwst(A>?v7 z7B5~b`W>`dE%Ng6uyyNJOq(_h>(;Hqy?ggW$AyQ7i}vZol~TTeX2@({gvzkoB_bjM zGMNlbO-&#on~y7r&|i%*nPaGb^O8dl0`GkCU!jMTup)#z#aJGR74-dzZB}VO3{QdXeF24f1c<~~3?b?NkiVD1W z^9J4B-F!KkGhg;NEA102<#W}CI}Dj*bXFGTF1fk6_~@gLkeHZ=kdP2;+O!F&si}DH zz4yGPaoe_SICt(G{QdoHcArT}Ns!58h>wqVsDl(@?%cT;GiD4D6B7{}9E_~2EEE(J zK%r1L^<|G(X`i!FK39FXg&PY@pD`55u==a<)vH%DcI;Tn%gghED(NA)4GiOdhzLiH z9D%>TKb9_C>T5YZ$D?GduCC^Hr1qcG)YJizID82R2*7~@2auDKW3zF2SL5nY37JNt z8I)47p-_g^AC2~}hI$#SxJnK7m}W=@mW&L^z><+68CWthB!l1vruXk<8H|C%*;&2A zoiQvd3}1cql~)BZ-d)scwP1d6^e(_i= Tn#Ol900000NkvXXu0mjfC(uMW literal 0 HcmV?d00001 diff --git a/docs/inherit_graph_1.map b/docs/inherit_graph_1.map new file mode 100644 index 0000000..b42c1a6 --- /dev/null +++ b/docs/inherit_graph_1.map @@ -0,0 +1,5 @@ + + + + + diff --git a/docs/inherit_graph_1.md5 b/docs/inherit_graph_1.md5 new file mode 100644 index 0000000..e042460 --- /dev/null +++ b/docs/inherit_graph_1.md5 @@ -0,0 +1 @@ +8c7803a7af3e17671ed7ae321b4143ff \ No newline at end of file diff --git a/docs/inherit_graph_1.png b/docs/inherit_graph_1.png new file mode 100644 index 0000000000000000000000000000000000000000..cf8ca6c8b92622c50489d19a6b9ea9e1f6a2901e GIT binary patch literal 7735 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 literal 0 HcmV?d00001 diff --git a/docs/inherit_graph_2.map b/docs/inherit_graph_2.map new file mode 100644 index 0000000..dcccbc8 --- /dev/null +++ b/docs/inherit_graph_2.map @@ -0,0 +1,3 @@ + + + diff --git a/docs/inherit_graph_2.md5 b/docs/inherit_graph_2.md5 new file mode 100644 index 0000000..b6e5f25 --- /dev/null +++ b/docs/inherit_graph_2.md5 @@ -0,0 +1 @@ +3d0887596ab86c69909ec3c03a5df941 \ No newline at end of file diff --git a/docs/inherit_graph_2.png b/docs/inherit_graph_2.png new file mode 100644 index 0000000000000000000000000000000000000000..0e3086df937d14537763213b03aa23264a94d78b GIT binary patch literal 3605 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 + + diff --git a/docs/inherit_graph_3.md5 b/docs/inherit_graph_3.md5 new file mode 100644 index 0000000..f67e243 --- /dev/null +++ b/docs/inherit_graph_3.md5 @@ -0,0 +1 @@ +e2a2fe710a3abdf8b9a45580a6a0ae4a \ No newline at end of file diff --git a/docs/inherit_graph_3.png b/docs/inherit_graph_3.png new file mode 100644 index 0000000000000000000000000000000000000000..a79681227001a2df66e5b0a8b3d529fbb24143c7 GIT binary patch literal 1696 zcmV;R24DG!P)rA{vo~9{h?ZO$?$drdlnS zv=T6SKxx9oAc+@^DMlq6OfWU56{3h5qi|6ZN^2w7YyoZE{B@Tz9wY8P42xs5a*x1NdJc!tH{P=N> zg6atb7vu>97vu>9mu2AzjYd;fR~NncckI}4=gytQjg59}006h!jbWJA>-~#!E+u6? zJh7Dc5d6c3CmasP>C>lqc+leb@#6;;3ZXE>hq7pM;J^X+bdgB3YuB!pmKOeFSQckT zY>AJLr+;(o*s7k(^tyY_tmp3vp!gBzN@r29eA_xM<@hw}n z+`4s(ISXYn*_$_S;5`&YVHoD~`M{rN$Jp4I#bQw^m220oJ$v@-#KZ)9=E=#)BS(%L zI&=u?8ja@S#fy9P?7?w7Gc)u3`}gp+k&%&;Cr^sS;^gGyQ>RXS|Neb$osHFM-MDe% z?Diad{`^^|)8RP2Y15`xuUqtR4URP5WgPb3mOdh{p|2v{tZ)YQ~9Yt|41F)%Oy zZzBi-!!UtBpj0ZaT)D#hGJ(B@PoF-W{ZJgoD=RC<$H(CpN=r#OQWoP0qtO^2AK%;C z`|{<>d-v`|G}dG?b#!zzH#a+-POVn^_U&8dlH2XxyLYcdB6;!RMPgzi6l-c~E?>S( zQIyeWJb3V+$KwG2oH%j9@Ar3hcDA*(ktAs{nc&Ug^d(}q+pSis+wC@+%_ftH`McKE z)?U4O)#vl&=jWTv=ANFOckkW}4i2WJrRnwhU@!;(XliPrY5Lc%U(cRByMO=w!-o&y z*htrq*OX}%4Gj$(Wj4LNy#RpW;bGW?8-vH=p=nwwmA-!c8tNoT0suxwM`@bgzJ0sR zW}|5uzCArXJ)Ai+GBV1`%aux{)oPusGu_RbH{ZT}`|H=Q005`c3B|6iE&#x{Z{Nb{ z>;UG4eReQ0+_-TAw&7byQ54kSd(R|0G&BUeGcz+dj(_^}i8Fb1b+yrGoO=y(a&q9= z;rIJXOG`x}k=yN#YRU$K!C)}3m5BEVilPz|6UAaN?5fr3g^%s;?~jX%3pu2=wszI3 zRV5`Q99^YSvD*|ykt8V;3Ka?k6yfGil4Ll2;o*gYNj4!N0RS*HH3hqJxg0i}PA33B zDwV?WFfJ}`Y;3H*zaIe5*w~nvnVFQ7gkhM)VxcGs%(sTs)zuh=NhFdFA3i*P{yaH3 zndg)v_Jm9(o0ynj3ZK5dKIT$FLISg1AuA(=LNPNl1KrKRYPF`Pr|;jte{^(|t;6MJ zo+XpXQc_Z;r>6%82cZbxxs;TYaC)Q(E*uQQU?Vj(RUi;}y2xp)K2wg^6Kb`3_wL>2&YkmkJbitA<>lqf zC5=XN_wHSv&o?kIaN)v**<fBu}BnhFMkt5>gHv0{b8;i#&rns*IDvc!}lWid5o zLqkI#5Kybt1VNb1W=5~9tn_-lQmK?6h@(f3h8$a0SC^iio|BWKQmNY8+q1K?{|!YT zu-R-noh~aY3+}N1fHP;#R8&+*B$E32`sU{5b?er_0FsiDwr$&{)oP_usoid80t>10 zfZc9SOH0em%@vEq=g*%nEG%5Pa-~9{xOVMYK|ukI<7H)K>@^9uhT-5fW%hQrkQ$SN z%jE*U>!ZI;Mn=Yi2M?k#GlJnS)R>6>J;)OXE=&DNfBpLPbkzQ9sI#*(N;4zo0PPb9 zF31xIF31xIF31xIE+J~n$B!TL9|s~b%@vUhs!4!D^B0000 + + + + + + +quickpool: Class Hierarchy + + + + + + + + + +
    +
    + + + + + + +
    +
    quickpool +  1.3.0 +
    +
    An easy-to-use, header-only work stealing thread pool in C++11
    +
    +
    + + + + + + + +
    + +
    +
    + + +
    + +
    + +
    +
    +
    Class Hierarchy
    +
    +
    +
    +

    Go to the textual class hierarchy

    +
    + + + + +
    + + + +
    + + + + + +
    + + + +
    + + + +
    +
    + +
    +Generated by   +doxygen + 1.8.17 +
    + + diff --git a/docs/namespacemembers.html b/docs/namespacemembers.html index 3aabf8c..2b76a7d 100644 --- a/docs/namespacemembers.html +++ b/docs/namespacemembers.html @@ -22,7 +22,7 @@
    quickpool -  1.3.0 +  1.4.0
    An easy-to-use, header-only work stealing thread pool in C++11
    diff --git a/docs/namespacemembers_func.html b/docs/namespacemembers_func.html index ccd460e..93d7701 100644 --- a/docs/namespacemembers_func.html +++ b/docs/namespacemembers_func.html @@ -22,7 +22,7 @@
    quickpool -  1.3.0 +  1.4.0
    An easy-to-use, header-only work stealing thread pool in C++11
    diff --git a/docs/namespacequickpool.html b/docs/namespacequickpool.html index dacd030..58da796 100644 --- a/docs/namespacequickpool.html +++ b/docs/namespacequickpool.html @@ -22,7 +22,7 @@
    quickpool -  1.3.0 +  1.4.0
    An easy-to-use, header-only work stealing thread pool in C++11
    @@ -164,7 +164,7 @@

    Returns
    A std::future for the task. Call future.get() to retrieve the results at a later point in time (blocking).
    -

    Definition at line 905 of file quickpool.hpp.

    +

    Definition at line 992 of file quickpool.hpp.

    @@ -221,7 +221,7 @@

    Definition at line 954 of file quickpool.hpp.

    +

    Definition at line 1041 of file quickpool.hpp.

    @@ -271,7 +271,7 @@

    Definition at line 971 of file quickpool.hpp.

    +

    Definition at line 1058 of file quickpool.hpp.

    @@ -320,7 +320,7 @@

    Definition at line 892 of file quickpool.hpp.

    +

    Definition at line 979 of file quickpool.hpp.

    @@ -356,7 +356,7 @@

    Definition at line 930 of file quickpool.hpp.

    +

    Definition at line 1017 of file quickpool.hpp.

    diff --git a/docs/namespacequickpool_1_1padding__impl.html b/docs/namespacequickpool_1_1padding__impl.html new file mode 100644 index 0000000..78116f6 --- /dev/null +++ b/docs/namespacequickpool_1_1padding__impl.html @@ -0,0 +1,104 @@ + + + + + + + +quickpool: quickpool::padding_impl Namespace Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    quickpool +  1.3.0 +
    +
    An easy-to-use, header-only work stealing thread pool in C++11
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Classes | +Functions
    +
    +
    quickpool::padding_impl Namespace Reference
    +
    +
    + + + + + + + + +

    +Classes

    struct  empty_struct
     
    struct  padding
     
    struct  padding_bytes
     
    + + + + +

    +Functions

    +constexpr size_t mod (size_t a, size_t b)
     constexpr modulo operator.
     
    +

    Detailed Description

    +

    Padding char[]s always must hold at least one char. If the size of the object ends at an alignment point, we don't want to pad one extra byte however. The construct below ensures that padding bytes are only added if necessary.

    +
    + +
    +Generated by   +doxygen + 1.8.17 +
    + + diff --git a/docs/namespaces.html b/docs/namespaces.html index 2b0a060..625f68b 100644 --- a/docs/namespaces.html +++ b/docs/namespaces.html @@ -22,7 +22,7 @@
    quickpool -  1.3.0 +  1.4.0
    An easy-to-use, header-only work stealing thread pool in C++11
    diff --git a/docs/quickpool_8hpp_source.html b/docs/quickpool_8hpp_source.html index 972dfe3..e5e8a17 100644 --- a/docs/quickpool_8hpp_source.html +++ b/docs/quickpool_8hpp_source.html @@ -22,7 +22,7 @@
    quickpool -  1.3.0 +  1.4.0
    An easy-to-use, header-only work stealing thread pool in C++11
    @@ -95,841 +95,923 @@
    26 #include <exception>
    27 #include <functional>
    28 #include <future>
    -
    29 #include <mutex>
    -
    30 #include <numeric>
    -
    31 #include <thread>
    -
    32 #include <vector>
    -
    33 
    -
    34 #if (defined __linux__ || defined AFFINITY)
    -
    35 #include <pthread.h>
    -
    36 #endif
    -
    37 
    -
    38 // Layout of quickpool.hpp
    -
    39 //
    -
    40 // 1. Memory related utilities.
    -
    41 // - Memory order aliases
    -
    42 // - Class for padding bytes
    -
    43 // - Class for cache aligned atomics
    -
    44 // - Class for load/assign atomics with relaxed order
    -
    45 // 2. Loop related utilities.
    -
    46 // - Worker class for parallel for loops
    -
    47 // 3. Scheduling utilities.
    -
    48 // - Ring buffer
    -
    49 // - Task queue
    -
    50 // - Task manager
    -
    51 // 4. Thread pool class
    -
    52 // 5. Free-standing functions (main API)
    -
    53 
    -
    55 namespace quickpool {
    -
    56 
    -
    57 // 1. --------------------------------------------------------------------------
    +
    29 #include <memory>
    +
    30 #include <mutex>
    +
    31 #include <numeric>
    +
    32 #include <thread>
    +
    33 #include <vector>
    +
    34 
    +
    35 #if (defined __linux__ || defined AFFINITY)
    +
    36 #include <pthread.h>
    +
    37 #endif
    +
    38 
    +
    39 // Layout of quickpool.hpp
    +
    40 //
    +
    41 // 1. Memory related utilities.
    +
    42 // - Memory order aliases
    +
    43 // - Class for padding bytes
    +
    44 // - Memory aligned allocation utilities
    +
    45 // - Class for cache aligned atomics
    +
    46 // - Class for load/assign atomics with relaxed order
    +
    47 // 2. Loop related utilities.
    +
    48 // - Worker class for parallel for loops
    +
    49 // 3. Scheduling utilities.
    +
    50 // - Ring buffer
    +
    51 // - Task queue
    +
    52 // - Task manager
    +
    53 // 4. Thread pool class
    +
    54 // 5. Free-standing functions (main API)
    +
    55 
    +
    57 namespace quickpool {
    58 
    -
    60 namespace mem {
    -
    61 
    -
    63 static constexpr std::memory_order relaxed = std::memory_order_relaxed;
    -
    64 static constexpr std::memory_order acquire = std::memory_order_acquire;
    -
    65 static constexpr std::memory_order release = std::memory_order_release;
    -
    66 static constexpr std::memory_order seq_cst = std::memory_order_seq_cst;
    -
    67 
    -
    72 namespace padding_impl {
    -
    73 
    -
    75 constexpr size_t
    -
    76 mod(size_t a, size_t b)
    -
    77 {
    -
    78  return a - b * (a / b);
    -
    79 }
    -
    80 
    -
    81 // Padding bytes from end of aligned object until next alignment point. char[]
    -
    82 // must hold at least one byte.
    -
    83 template<class T, size_t Align>
    -
    84 struct padding_bytes
    -
    85 {
    -
    86  static constexpr size_t free_space =
    -
    87  Align - mod(sizeof(std::atomic<T>), Align);
    -
    88  static constexpr size_t required = free_space > 1 ? free_space : 1;
    -
    89  char padding_[required];
    -
    90 };
    -
    91 
    -
    92 struct empty_struct
    -
    93 {};
    -
    94 
    -
    97 template<class T, size_t Align>
    -
    98 struct padding
    -
    99  : std::conditional<mod(sizeof(std::atomic<T>), Align) != 0,
    -
    100  padding_bytes<T, Align>,
    -
    101  empty_struct>::type
    -
    102 {};
    -
    103 
    -
    104 } // end namespace padding_impl
    +
    59 // 1. --------------------------------------------------------------------------
    +
    60 
    +
    62 namespace mem {
    +
    63 
    +
    65 static constexpr std::memory_order relaxed = std::memory_order_relaxed;
    +
    66 static constexpr std::memory_order acquire = std::memory_order_acquire;
    +
    67 static constexpr std::memory_order release = std::memory_order_release;
    +
    68 static constexpr std::memory_order seq_cst = std::memory_order_seq_cst;
    +
    69 
    +
    74 namespace padding_impl {
    +
    75 
    +
    77 constexpr size_t
    +
    78 mod(size_t a, size_t b)
    +
    79 {
    +
    80  return a - b * (a / b);
    +
    81 }
    +
    82 
    +
    83 // Padding bytes from end of aligned object until next alignment point. char[]
    +
    84 // must hold at least one byte.
    +
    85 template<class T, size_t Align>
    +
    86 struct padding_bytes
    +
    87 {
    +
    88  static constexpr size_t free_space =
    +
    89  Align - mod(sizeof(std::atomic<T>), Align);
    +
    90  static constexpr size_t required = free_space > 1 ? free_space : 1;
    +
    91  char padding_[required];
    +
    92 };
    +
    93 
    +
    94 struct empty_struct
    +
    95 {};
    +
    96 
    +
    99 template<class T, size_t Align>
    +
    100 struct padding
    +
    101  : std::conditional<mod(sizeof(std::atomic<T>), Align) != 0,
    +
    102  padding_bytes<T, Align>,
    +
    103  empty_struct>::type
    +
    104 {};
    105 
    -
    109 template<class T, size_t Align = 64>
    -
    110 struct alignas(Align) aligned_atomic
    -
    111  : public std::atomic<T>
    -
    112  , private padding_impl::padding<T, Align>
    -
    113 {
    -
    114  public:
    -
    115  aligned_atomic() noexcept = default;
    -
    116 
    -
    117  aligned_atomic(T desired) noexcept
    -
    118  : std::atomic<T>(desired)
    -
    119  {}
    -
    120 
    -
    121  // Assignment operators have been deleted, must redefine.
    -
    122  T operator=(T x) noexcept { return std::atomic<T>::operator=(x); }
    -
    123  T operator=(T x) volatile noexcept { return std::atomic<T>::operator=(x); }
    -
    124 
    -
    125  // The alloc/dealloc mechanism is pretty much
    -
    126  // https://www.boost.org/doc/libs/1_76_0/boost/align/detail/aligned_alloc.hpp
    -
    127  static void* operator new(size_t count) noexcept
    -
    128  {
    -
    129  // Make sure alignment is at least that of void*.
    -
    130  constexpr size_t alignment =
    -
    131  (Align >= alignof(void*)) ? Align : alignof(void*);
    +
    106 } // end namespace padding_impl
    +
    107 
    +
    108 namespace aligned {
    +
    109 
    +
    110 // The alloc/dealloc mechanism is pretty much
    +
    111 // https://www.boost.org/doc/libs/1_76_0/boost/align/detail/aligned_alloc.hpp
    +
    112 
    +
    113 inline void*
    +
    114 alloc(size_t alignment, size_t size) noexcept
    +
    115 {
    +
    116  // Make sure alignment is at least that of void*.
    +
    117  alignment = (alignment >= alignof(void*)) ? alignment : alignof(void*);
    +
    118 
    +
    119  // Allocate enough space required for object and a void*.
    +
    120  size_t space = size + alignment + sizeof(void*);
    +
    121  void* p = std::malloc(space);
    +
    122  if (p == nullptr) {
    +
    123  return nullptr;
    +
    124  }
    +
    125 
    +
    126  // Shift pointer to leave space for void*.
    +
    127  void* p_algn = static_cast<char*>(p) + sizeof(void*);
    +
    128  space -= sizeof(void*);
    +
    129 
    +
    130  // Shift pointer further to ensure proper alignment.
    +
    131  (void)std::align(alignment, size, p_algn, space);
    132 
    -
    133  // Allocate enough space required for object and a void*.
    -
    134  size_t space = count + alignment + sizeof(void*);
    -
    135  void* p = std::malloc(space);
    -
    136  if (p == nullptr) {
    -
    137  return nullptr;
    -
    138  }
    -
    139 
    -
    140  // Shift pointer to leave space for void*.
    -
    141  void* p_algn = static_cast<char*>(p) + sizeof(void*);
    -
    142  space -= sizeof(void*);
    -
    143 
    -
    144  // Shift pointer further to ensure proper alignment.
    -
    145  (void)std::align(alignment, count, p_algn, space);
    -
    146 
    -
    147  // Store unaligned pointer with offset sizeof(void*) before aligned
    -
    148  // location. Later we'll know where to look for the pointer telling
    -
    149  // us where to free what we malloc()'ed above.
    -
    150  *(static_cast<void**>(p_algn) - 1) = p;
    -
    151 
    -
    152  return p_algn;
    -
    153  }
    -
    154 
    -
    155  static void operator delete(void* ptr)
    -
    156  {
    -
    157  if (ptr) {
    -
    158  // Read pointer to start of malloc()'ed block and free there.
    -
    159  std::free(*(static_cast<void**>(ptr) - 1));
    -
    160  }
    -
    161  }
    -
    162 };
    -
    163 
    -
    165 template<typename T>
    -
    166 struct relaxed_atomic : public aligned_atomic<T>
    -
    167 {
    -
    168  explicit relaxed_atomic(T value)
    -
    169  : mem::aligned_atomic<T>(value)
    -
    170  {}
    -
    171 
    -
    172  operator T() const noexcept { return this->load(mem::relaxed); }
    -
    173 
    -
    174  T operator=(T desired) noexcept
    -
    175  {
    -
    176  this->store(desired, mem::relaxed);
    -
    177  return desired;
    -
    178  }
    -
    179 };
    -
    180 
    -
    181 } // end namespace mem
    -
    182 
    -
    183 // 2. --------------------------------------------------------------------------
    +
    133  // Store unaligned pointer with offset sizeof(void*) before aligned
    +
    134  // location. Later we'll know where to look for the pointer telling
    +
    135  // us where to free what we malloc()'ed above.
    +
    136  *(static_cast<void**>(p_algn) - 1) = p;
    +
    137 
    +
    138  return p_algn;
    +
    139 }
    +
    140 
    +
    141 inline void
    +
    142 free(void* ptr) noexcept
    +
    143 {
    +
    144  if (ptr) {
    +
    145  std::free(*(static_cast<void**>(ptr) - 1));
    +
    146  }
    +
    147 }
    +
    148 
    +
    151 template<class T, std::size_t Alignment = 64>
    +
    152 class allocator : public std::allocator<T>
    +
    153 {
    +
    154  private:
    +
    155  static constexpr size_t min_align =
    +
    156  (Alignment >= alignof(void*)) ? Alignment : alignof(void*);
    +
    157 
    +
    158  public:
    +
    159  template<class U>
    +
    160  struct rebind
    +
    161  {
    +
    162  typedef allocator<U, Alignment> other;
    +
    163  };
    +
    164 
    +
    165  T* allocate(size_t size, const void* = 0)
    +
    166  {
    +
    167  if (size == 0) {
    +
    168  return 0;
    +
    169  }
    +
    170  void* p = mem::aligned::alloc(min_align, sizeof(T) * size);
    +
    171  if (!p) {
    +
    172  throw std::bad_alloc();
    +
    173  }
    +
    174  return static_cast<T*>(p);
    +
    175  }
    +
    176 
    +
    177  void deallocate(T* ptr, size_t) { mem::aligned::free(ptr); }
    +
    178 
    +
    179  template<class U, class... Args>
    +
    180  void construct(U* ptr, Args&&... args)
    +
    181  {
    +
    182  ::new ((void*)ptr) U(std::forward<Args>(args)...);
    +
    183  }
    184 
    -
    186 namespace loop {
    -
    187 
    -
    189 struct State
    -
    190 {
    -
    191  int pos;
    -
    192  int end;
    -
    193 };
    -
    194 
    -
    205 template<typename Function>
    -
    206 struct Worker
    -
    207 {
    -
    208  Worker() {}
    -
    209  Worker(int begin, int end, Function fun)
    -
    210  : state{ State{ begin, end } }
    -
    211  , f{ fun }
    -
    212  {}
    -
    213 
    -
    214  Worker(Worker&& other)
    -
    215  : state{ other.state.load() }
    -
    216  , f{ std::forward<Function>(other.f) }
    -
    217  {}
    -
    218 
    -
    219  size_t tasks_left() const
    -
    220  {
    -
    221  State s = state;
    -
    222  return s.end - s.pos;
    -
    223  }
    -
    224 
    -
    225  bool done() const { return (tasks_left() == 0); }
    -
    226 
    -
    228  void run(std::shared_ptr<std::vector<Worker>> others)
    -
    229  {
    -
    230  State s, s_old; // temporary state variables
    -
    231  do {
    -
    232  s = state;
    -
    233  if (s.pos < s.end) {
    -
    234  // Protect slot by trying to advance position before doing work.
    -
    235  s_old = s;
    -
    236  s.pos++;
    -
    237 
    -
    238  // Another worker might have changed the end of the range in
    -
    239  // the meanwhile. Check atomically if the state is unaltered
    -
    240  // and, if so, replace by advanced state.
    -
    241  if (state.compare_exchange_weak(s_old, s)) {
    -
    242  f(s_old.pos); // succeeded, do work
    -
    243  } else {
    -
    244  continue; // failed, try again
    -
    245  }
    -
    246  }
    -
    247  if (s.pos == s.end) {
    -
    248  // Reached end of own range, steal range from others. Range
    -
    249  // remains empty if all work is done, so we can leave the loop.
    -
    250  this->steal_range(*others);
    -
    251  }
    -
    252  } while (!this->done());
    -
    253  }
    -
    254 
    -
    256  void steal_range(std::vector<Worker>& workers)
    -
    257  {
    -
    258  do {
    -
    259  Worker& other = find_victim(workers);
    -
    260  State s = other.state;
    -
    261  if (s.pos >= s.end) {
    -
    262  continue; // other range is empty by now
    -
    263  }
    -
    264 
    -
    265  // Remove second half of the range. Check atomically if the state is
    -
    266  // unaltered and, if so, replace with reduced range.
    -
    267  auto s_old = s;
    -
    268  s.end -= (s.end - s.pos + 1) / 2;
    -
    269  if (other.state.compare_exchange_weak(s_old, s)) {
    -
    270  // succeeded, update own range
    -
    271  state = State{ s.end, s_old.end };
    -
    272  break;
    -
    273  }
    -
    274  } while (!all_done(workers)); // failed steal, try again
    -
    275  }
    -
    276 
    -
    278  bool all_done(const std::vector<Worker>& workers)
    -
    279  {
    -
    280  for (const auto& worker : workers) {
    -
    281  if (!worker.done())
    -
    282  return false;
    -
    283  }
    -
    284  return true;
    +
    185  template<class U>
    +
    186  void destroy(U* ptr)
    +
    187  {
    +
    188  (void)ptr;
    +
    189  ptr->~U();
    +
    190  }
    +
    191 };
    +
    192 
    +
    196 template<class T, size_t Align = 64>
    +
    197 struct alignas(Align) atomic
    +
    198  : public std::atomic<T>
    +
    199  , private padding_impl::padding<T, Align>
    +
    200 {
    +
    201  public:
    +
    202  atomic() noexcept = default;
    +
    203 
    +
    204  atomic(T desired) noexcept
    +
    205  : std::atomic<T>(desired)
    +
    206  {}
    +
    207 
    +
    208  // Assignment operators have been deleted, must redefine.
    +
    209  T operator=(T x) noexcept { return std::atomic<T>::operator=(x); }
    +
    210  T operator=(T x) volatile noexcept { return std::atomic<T>::operator=(x); }
    +
    211 
    +
    212  static void* operator new(size_t count) noexcept
    +
    213  {
    +
    214  return mem::aligned::alloc(Align, count);
    +
    215  }
    +
    216 
    +
    217  static void operator delete(void* ptr) { mem::aligned::free(ptr); }
    +
    218 };
    +
    219 
    +
    221 template<typename T>
    +
    222 struct relaxed_atomic : public mem::aligned::atomic<T>
    +
    223 {
    +
    224  explicit relaxed_atomic(T value)
    +
    225  : mem::aligned::atomic<T>(value)
    +
    226  {}
    +
    227 
    +
    228  operator T() const noexcept { return this->load(mem::relaxed); }
    +
    229 
    +
    230  T operator=(T desired) noexcept
    +
    231  {
    +
    232  this->store(desired, mem::relaxed);
    +
    233  return desired;
    +
    234  }
    +
    235 };
    +
    236 
    +
    238 template<class T, size_t Alignment = 64>
    +
    239 using vector = std::vector<T, mem::aligned::allocator<T, Alignment>>;
    +
    240 
    +
    241 } // end namespace aligned
    +
    242 
    +
    243 } // end namespace mem
    +
    244 
    +
    245 // 2. --------------------------------------------------------------------------
    +
    246 
    +
    248 namespace loop {
    +
    249 
    +
    251 struct State
    +
    252 {
    +
    253  int pos;
    +
    254  int end;
    +
    255 };
    +
    256 
    +
    267 template<typename Function>
    +
    268 struct Worker
    +
    269 {
    +
    270  Worker() {}
    +
    271  Worker(int begin, int end, Function fun)
    +
    272  : state{ State{ begin, end } }
    +
    273  , f{ fun }
    +
    274  {}
    +
    275 
    +
    276  Worker(Worker&& other)
    +
    277  : state{ other.state.load() }
    +
    278  , f{ std::forward<Function>(other.f) }
    +
    279  {}
    +
    280 
    +
    281  size_t tasks_left() const
    +
    282  {
    +
    283  State s = state.load();
    +
    284  return s.end - s.pos;
    285  }
    286 
    -
    290  Worker& find_victim(std::vector<Worker>& workers)
    +
    287  bool done() const { return (tasks_left() == 0); }
    +
    288 
    +
    290  void run(std::shared_ptr<mem::aligned::vector<Worker>> others)
    291  {
    -
    292  std::vector<size_t> tasks_left;
    -
    293  tasks_left.reserve(workers.size());
    -
    294  for (const auto& worker : workers) {
    -
    295  tasks_left.push_back(worker.tasks_left());
    -
    296  }
    -
    297  auto max_it = std::max_element(tasks_left.begin(), tasks_left.end());
    -
    298  auto idx = std::distance(tasks_left.begin(), max_it);
    -
    299  return workers[idx];
    -
    300  }
    -
    301 
    -
    302  mem::relaxed_atomic<State> state;
    -
    303  Function f; //< function applied to the loop index
    -
    304 };
    -
    305 
    -
    309 template<typename Function>
    -
    310 std::shared_ptr<std::vector<Worker<Function>>>
    -
    311 create_workers(const Function& f, int begin, int end, size_t num_workers)
    -
    312 {
    -
    313  auto num_tasks = std::max(end - begin, static_cast<int>(0));
    -
    314  num_workers = std::max(num_workers, static_cast<size_t>(1));
    -
    315  auto workers = new std::vector<Worker<Function>>;
    -
    316  workers->reserve(num_workers);
    -
    317  for (size_t i = 0; i < num_workers; i++) {
    -
    318  workers->emplace_back(begin + num_tasks * i / num_workers,
    -
    319  begin + num_tasks * (i + 1) / num_workers,
    -
    320  f);
    -
    321  }
    -
    322  return std::shared_ptr<std::vector<Worker<Function>>>(std::move(workers));
    -
    323 }
    -
    324 
    -
    325 } // end namespace loop
    -
    326 
    -
    327 // 3. -------------------------------------------------------------------------
    +
    292  State s, s_old; // temporary state variables
    +
    293  do {
    +
    294  s = state.load();
    +
    295  if (s.pos < s.end) {
    +
    296  // Protect slot by trying to advance position before doing
    +
    297  // work.
    +
    298  s_old = s;
    +
    299  s.pos++;
    +
    300 
    +
    301  // Another worker might have changed the end of the range in
    +
    302  // the meanwhile. Check atomically if the state is unaltered
    +
    303  // and, if so, replace by advanced state.
    +
    304  if (state.compare_exchange_weak(s_old, s)) {
    +
    305  f(s_old.pos); // succeeded, do work
    +
    306  } else {
    +
    307  continue; // failed, try again
    +
    308  }
    +
    309  }
    +
    310  if (s.pos == s.end) {
    +
    311  // Reached end of own range, steal range from others. Range
    +
    312  // remains empty if all work is done, so we can leave the
    +
    313  // loop.
    +
    314  this->steal_range(*others);
    +
    315  }
    +
    316  } while (!this->done());
    +
    317  }
    +
    318 
    +
    320  void steal_range(mem::aligned::vector<Worker>& workers)
    +
    321  {
    +
    322  do {
    +
    323  Worker& other = find_victim(workers);
    +
    324  State s = other.state.load();
    +
    325  if (s.pos >= s.end) {
    +
    326  continue; // other range is empty by now
    +
    327  }
    328 
    -
    330 namespace sched {
    -
    331 
    -
    333 template<typename T>
    -
    334 class RingBuffer
    -
    335 {
    -
    336  public:
    -
    337  explicit RingBuffer(size_t capacity)
    -
    338  : buffer_{ std::unique_ptr<T[]>(new T[capacity]) }
    -
    339  , capacity_{ capacity }
    -
    340  , mask_{ capacity - 1 }
    -
    341  {}
    -
    342 
    -
    343  size_t capacity() const { return capacity_; }
    -
    344 
    -
    345  void set_entry(size_t i, T val) { buffer_[i & mask_] = val; }
    -
    346 
    -
    347  T get_entry(size_t i) const { return buffer_[i & mask_]; }
    -
    348 
    -
    349  RingBuffer<T>* enlarged_copy(size_t bottom, size_t top) const
    -
    350  {
    -
    351  RingBuffer<T>* new_buffer = new RingBuffer{ 2 * capacity_ };
    -
    352  for (size_t i = top; i != bottom; ++i)
    -
    353  new_buffer->set_entry(i, this->get_entry(i));
    -
    354  return new_buffer;
    -
    355  }
    -
    356 
    -
    357  private:
    -
    358  std::unique_ptr<T[]> buffer_;
    -
    359  size_t capacity_;
    -
    360  size_t mask_;
    -
    361 };
    -
    362 
    -
    364 class TaskQueue
    -
    365 {
    -
    366  using Task = std::function<void()>;
    -
    367 
    -
    368  public:
    -
    370  TaskQueue(size_t capacity = 256)
    -
    371  : buffer_{ new RingBuffer<Task*>(capacity) }
    -
    372  {}
    -
    373 
    -
    374  ~TaskQueue() noexcept
    -
    375  {
    -
    376  // Must free memory allocated by push(), but not freed by try_pop().
    -
    377  auto buf_ptr = buffer_.load();
    -
    378  for (int i = top_; i < bottom_.load(mem::relaxed); ++i)
    -
    379  delete buf_ptr->get_entry(i);
    -
    380  delete buf_ptr;
    -
    381  }
    -
    382 
    -
    383  TaskQueue(TaskQueue const& other) = delete;
    -
    384  TaskQueue& operator=(TaskQueue const& other) = delete;
    -
    385 
    -
    387  bool empty() const
    -
    388  {
    -
    389  return (bottom_.load(mem::relaxed) <= top_.load(mem::relaxed));
    -
    390  }
    +
    329  // Remove second half of the range. Check atomically if the
    +
    330  // state is unaltered and, if so, replace with reduced range.
    +
    331  auto s_old = s;
    +
    332  s.end -= (s.end - s.pos + 1) / 2;
    +
    333  if (other.state.compare_exchange_weak(s_old, s)) {
    +
    334  // succeeded, update own range
    +
    335  state = State{ s.end, s_old.end };
    +
    336  break;
    +
    337  }
    +
    338  } while (!all_done(workers)); // failed steal, try again
    +
    339  }
    +
    340 
    +
    342  bool all_done(const mem::aligned::vector<Worker>& workers)
    +
    343  {
    +
    344  for (const auto& worker : workers) {
    +
    345  if (!worker.done())
    +
    346  return false;
    +
    347  }
    +
    348  return true;
    +
    349  }
    +
    350 
    +
    354  Worker& find_victim(mem::aligned::vector<Worker>& workers)
    +
    355  {
    +
    356  std::vector<size_t> tasks_left;
    +
    357  tasks_left.reserve(workers.size());
    +
    358  for (const auto& worker : workers) {
    +
    359  tasks_left.push_back(worker.tasks_left());
    +
    360  }
    +
    361  auto max_it = std::max_element(tasks_left.begin(), tasks_left.end());
    +
    362  auto idx = std::distance(tasks_left.begin(), max_it);
    +
    363  return workers[idx];
    +
    364  }
    +
    365 
    +
    366  mem::aligned::relaxed_atomic<State> state;
    +
    367  Function f; //< function applied to the loop index
    +
    368 };
    +
    369 
    +
    373 template<typename Function>
    +
    374 std::shared_ptr<mem::aligned::vector<Worker<Function>>>
    +
    375 create_workers(const Function& f, int begin, int end, size_t num_workers)
    +
    376 {
    +
    377  auto num_tasks = std::max(end - begin, static_cast<int>(0));
    +
    378  num_workers = std::max(num_workers, static_cast<size_t>(1));
    +
    379  auto workers = new mem::aligned::vector<Worker<Function>>;
    +
    380  workers->reserve(num_workers);
    +
    381  for (size_t i = 0; i < num_workers; i++) {
    +
    382  workers->emplace_back(begin + num_tasks * i / num_workers,
    +
    383  begin + num_tasks * (i + 1) / num_workers,
    +
    384  f);
    +
    385  }
    +
    386  return std::shared_ptr<mem::aligned::vector<Worker<Function>>>(
    +
    387  std::move(workers));
    +
    388 }
    +
    389 
    +
    390 } // end namespace loop
    391 
    -
    394  void push(Task&& task)
    -
    395  {
    -
    396  // Must hold lock in case of multiple producers.
    -
    397  std::unique_lock<std::mutex> lk(mutex_);
    -
    398  auto b = bottom_.load(mem::relaxed);
    -
    399  auto t = top_.load(mem::acquire);
    -
    400  RingBuffer<Task*>* buf_ptr = buffer_.load(mem::relaxed);
    -
    401 
    -
    402  if (static_cast<int>(buf_ptr->capacity()) < (b - t) + 1) {
    -
    403  // Buffer is full, create enlarged copy before continuing.
    -
    404  auto old_buf = buf_ptr;
    -
    405  buf_ptr = std::move(buf_ptr->enlarged_copy(b, t));
    -
    406  old_buffers_.emplace_back(old_buf);
    -
    407  buffer_.store(buf_ptr, mem::relaxed);
    -
    408  }
    +
    392 // 3. -------------------------------------------------------------------------
    +
    393 
    +
    395 namespace sched {
    +
    396 
    +
    398 template<typename T>
    +
    399 class RingBuffer
    +
    400 {
    +
    401  public:
    +
    402  explicit RingBuffer(size_t capacity)
    +
    403  : buffer_{ std::unique_ptr<T[]>(new T[capacity]) }
    +
    404  , capacity_{ capacity }
    +
    405  , mask_{ capacity - 1 }
    +
    406  {}
    +
    407 
    +
    408  size_t capacity() const { return capacity_; }
    409 
    -
    411  buf_ptr->set_entry(b, new Task{ std::forward<Task>(task) });
    -
    412  bottom_.store(b + 1, mem::release);
    +
    410  void set_entry(size_t i, T val) { buffer_[i & mask_] = val; }
    +
    411 
    +
    412  T get_entry(size_t i) const { return buffer_[i & mask_]; }
    413 
    -
    414  lk.unlock(); // can release before signal
    -
    415  cv_.notify_one();
    -
    416  }
    -
    417 
    -
    419  bool try_pop(Task& task)
    -
    420  {
    -
    421  auto t = top_.load(mem::acquire);
    -
    422  std::atomic_thread_fence(mem::seq_cst);
    -
    423  auto b = bottom_.load(mem::acquire);
    -
    424 
    -
    425  if (t < b) {
    -
    426  // Must load task pointer before acquiring the slot, because it
    -
    427  // could be overwritten immediately after.
    -
    428  auto task_ptr = buffer_.load(mem::acquire)->get_entry(t);
    -
    429 
    -
    430  // Atomically try to advance top.
    -
    431  if (top_.compare_exchange_strong(
    -
    432  t, t + 1, mem::seq_cst, mem::relaxed)) {
    -
    433  task = std::move(*task_ptr); // won race, get task
    -
    434  delete task_ptr; // fre memory allocated in push()
    -
    435  return true;
    -
    436  }
    -
    437  }
    -
    438  return false; // queue is empty or lost race
    -
    439  }
    -
    440 
    -
    442  void wait()
    -
    443  {
    -
    444  std::unique_lock<std::mutex> lk(mutex_);
    -
    445  cv_.wait(lk, [this] { return !this->empty() || stopped_; });
    +
    414  RingBuffer<T>* enlarged_copy(size_t bottom, size_t top) const
    +
    415  {
    +
    416  RingBuffer<T>* new_buffer = new RingBuffer{ 2 * capacity_ };
    +
    417  for (size_t i = top; i != bottom; ++i)
    +
    418  new_buffer->set_entry(i, this->get_entry(i));
    +
    419  return new_buffer;
    +
    420  }
    +
    421 
    +
    422  private:
    +
    423  std::unique_ptr<T[]> buffer_;
    +
    424  size_t capacity_;
    +
    425  size_t mask_;
    +
    426 };
    +
    427 
    +
    429 class TaskQueue
    +
    430 {
    +
    431  using Task = std::function<void()>;
    +
    432 
    +
    433  public:
    +
    435  TaskQueue(size_t capacity = 256)
    +
    436  : buffer_{ new RingBuffer<Task*>(capacity) }
    +
    437  {}
    +
    438 
    +
    439  ~TaskQueue() noexcept
    +
    440  {
    +
    441  // Must free memory allocated by push(), but not freed by try_pop().
    +
    442  auto buf_ptr = buffer_.load();
    +
    443  for (int i = top_; i < bottom_.load(mem::relaxed); ++i)
    +
    444  delete buf_ptr->get_entry(i);
    +
    445  delete buf_ptr;
    446  }
    447 
    -
    449  void stop()
    -
    450  {
    -
    451  {
    -
    452  std::lock_guard<std::mutex> lk(mutex_);
    -
    453  stopped_ = true;
    -
    454  }
    -
    455  cv_.notify_one();
    -
    456  }
    -
    457 
    -
    458  void wake_up()
    -
    459  {
    -
    460  {
    -
    461  std::lock_guard<std::mutex> lk(mutex_);
    -
    462  }
    -
    463  cv_.notify_one();
    -
    464  }
    -
    465 
    -
    466  private:
    -
    468  mem::aligned_atomic<int> top_{ 0 };
    -
    469  mem::aligned_atomic<int> bottom_{ 0 };
    -
    470 
    -
    472  std::atomic<RingBuffer<Task*>*> buffer_{ nullptr };
    -
    473 
    -
    475  std::vector<std::unique_ptr<RingBuffer<Task*>>> old_buffers_;
    -
    476 
    -
    478  std::mutex mutex_;
    -
    479  std::condition_variable cv_;
    -
    480  bool stopped_{ false };
    -
    481 };
    +
    448  TaskQueue(TaskQueue const& other) = delete;
    +
    449  TaskQueue& operator=(TaskQueue const& other) = delete;
    +
    450 
    +
    452  bool empty() const
    +
    453  {
    +
    454  return (bottom_.load(mem::relaxed) <= top_.load(mem::relaxed));
    +
    455  }
    +
    456 
    +
    459  void push(Task&& task)
    +
    460  {
    +
    461  // Must hold lock in case of multiple producers.
    +
    462  std::unique_lock<std::mutex> lk(mutex_);
    +
    463  auto b = bottom_.load(mem::relaxed);
    +
    464  auto t = top_.load(mem::acquire);
    +
    465  RingBuffer<Task*>* buf_ptr = buffer_.load(mem::relaxed);
    +
    466 
    +
    467  if (static_cast<int>(buf_ptr->capacity()) < (b - t) + 1) {
    +
    468  // Buffer is full, create enlarged copy before continuing.
    +
    469  auto old_buf = buf_ptr;
    +
    470  buf_ptr = std::move(buf_ptr->enlarged_copy(b, t));
    +
    471  old_buffers_.emplace_back(old_buf);
    +
    472  buffer_.store(buf_ptr, mem::relaxed);
    +
    473  }
    +
    474 
    +
    476  buf_ptr->set_entry(b, new Task{ std::forward<Task>(task) });
    +
    477  bottom_.store(b + 1, mem::release);
    +
    478 
    +
    479  lk.unlock(); // can release before signal
    +
    480  cv_.notify_one();
    +
    481  }
    482 
    -
    484 class TaskManager
    -
    485 {
    -
    486  public:
    -
    487  explicit TaskManager(size_t num_queues)
    -
    488  : queues_{ std::vector<TaskQueue>(num_queues) }
    -
    489  , num_queues_{ num_queues }
    -
    490  , owner_id_{ std::this_thread::get_id() }
    -
    491  {}
    -
    492 
    -
    493  void resize(size_t num_queues)
    -
    494  {
    -
    495  num_queues_ = std::max(num_queues, static_cast<size_t>(1));
    -
    496  if (num_queues > queues_.size()) {
    -
    497  queues_ = std::vector<TaskQueue>(num_queues);
    -
    498  // thread pool must have stopped the manager, reset
    -
    499  num_waiting_ = 0;
    -
    500  todo_ = 0;
    -
    501  status_ = Status::running;
    +
    484  bool try_pop(Task& task)
    +
    485  {
    +
    486  auto t = top_.load(mem::acquire);
    +
    487  std::atomic_thread_fence(mem::seq_cst);
    +
    488  auto b = bottom_.load(mem::acquire);
    +
    489 
    +
    490  if (t < b) {
    +
    491  // Must load task pointer before acquiring the slot, because it
    +
    492  // could be overwritten immediately after.
    +
    493  auto task_ptr = buffer_.load(mem::acquire)->get_entry(t);
    +
    494 
    +
    495  // Atomically try to advance top.
    +
    496  if (top_.compare_exchange_strong(
    +
    497  t, t + 1, mem::seq_cst, mem::relaxed)) {
    +
    498  task = std::move(*task_ptr); // won race, get task
    +
    499  delete task_ptr; // fre memory allocated in push()
    +
    500  return true;
    +
    501  }
    502  }
    -
    503  }
    -
    504 
    -
    505  template<typename Task>
    -
    506  void push(Task&& task)
    -
    507  {
    -
    508  rethrow_exception(); // push() throws if a task has errored.
    -
    509  if (is_running()) {
    -
    510  todo_.fetch_add(1, mem::release);
    -
    511  queues_[push_idx_++ % num_queues_].push(task);
    -
    512  }
    -
    513  }
    -
    514 
    -
    515  template<typename Task>
    -
    516  bool try_pop(Task& task, size_t worker_id = 0)
    -
    517  {
    -
    518  // Always start pop cycle at own queue to avoid contention.
    -
    519  for (size_t k = 0; k <= num_queues_; k++) {
    -
    520  if (queues_[(worker_id + k) % num_queues_].try_pop(task)) {
    -
    521  if (is_running()) {
    -
    522  return true;
    -
    523  } else {
    -
    524  // Throw away task if pool has stopped or errored.
    -
    525  return false;
    -
    526  }
    -
    527  }
    -
    528  }
    -
    529 
    -
    530  return false;
    -
    531  }
    -
    532 
    -
    533  void wake_up_all_workers()
    -
    534  {
    -
    535  for (auto& q : queues_)
    -
    536  q.wake_up();
    -
    537  }
    +
    503  return false; // queue is empty or lost race
    +
    504  }
    +
    505 
    +
    507  void wait()
    +
    508  {
    +
    509  std::unique_lock<std::mutex> lk(mutex_);
    +
    510  cv_.wait(lk, [this] { return !this->empty() || stopped_; });
    +
    511  }
    +
    512 
    +
    514  void stop()
    +
    515  {
    +
    516  {
    +
    517  std::lock_guard<std::mutex> lk(mutex_);
    +
    518  stopped_ = true;
    +
    519  }
    +
    520  cv_.notify_one();
    +
    521  }
    +
    522 
    +
    523  void wake_up()
    +
    524  {
    +
    525  {
    +
    526  std::lock_guard<std::mutex> lk(mutex_);
    +
    527  }
    +
    528  cv_.notify_one();
    +
    529  }
    +
    530 
    +
    531  private:
    +
    533  mem::aligned::atomic<int> top_{ 0 };
    +
    534  mem::aligned::atomic<int> bottom_{ 0 };
    +
    535 
    +
    537  std::atomic<RingBuffer<Task*>*> buffer_{ nullptr };
    538 
    -
    539  void wait_for_jobs(size_t id)
    -
    540  {
    -
    541  if (has_errored()) {
    -
    542  // Main thread may be waiting to reset the pool.
    -
    543  std::lock_guard<std::mutex> lk(mtx_);
    -
    544  if (++num_waiting_ == queues_.size())
    -
    545  cv_.notify_all();
    -
    546  } else {
    -
    547  ++num_waiting_;
    -
    548  }
    -
    549 
    -
    550  queues_[id].wait();
    -
    551  --num_waiting_;
    -
    552  }
    -
    553 
    -
    555  void wait_for_finish(size_t millis = 0)
    -
    556  {
    -
    557  if (called_from_owner_thread() && is_running()) {
    -
    558  auto wake_up = [this] { return (todo_ <= 0) || !is_running(); };
    -
    559  std::unique_lock<std::mutex> lk(mtx_);
    -
    560  if (millis == 0) {
    -
    561  cv_.wait(lk, wake_up);
    -
    562  } else {
    -
    563  cv_.wait_for(lk, std::chrono::milliseconds(millis), wake_up);
    -
    564  }
    -
    565  }
    -
    566  rethrow_exception();
    +
    540  std::vector<std::unique_ptr<RingBuffer<Task*>>> old_buffers_;
    +
    541 
    +
    543  std::mutex mutex_;
    +
    544  std::condition_variable cv_;
    +
    545  bool stopped_{ false };
    +
    546 };
    +
    547 
    +
    549 class TaskManager
    +
    550 {
    +
    551  public:
    +
    552  explicit TaskManager(size_t num_queues)
    +
    553  : queues_(num_queues)
    +
    554  , num_queues_(num_queues)
    +
    555  , owner_id_(std::this_thread::get_id())
    +
    556  {}
    +
    557 
    +
    558  TaskManager& operator=(TaskManager&& other)
    +
    559  {
    +
    560  std::swap(queues_, other.queues_);
    +
    561  num_queues_ = other.num_queues_;
    +
    562  status_ = other.status_.load();
    +
    563  num_waiting_ = other.num_waiting_.load();
    +
    564  push_idx_ = other.push_idx_.load();
    +
    565  todo_ = other.todo_.load();
    +
    566  return *this;
    567  }
    568 
    -
    569  bool called_from_owner_thread() const
    -
    570  {
    -
    571  return (std::this_thread::get_id() == owner_id_);
    -
    572  }
    -
    573 
    -
    574  void report_success()
    -
    575  {
    -
    576 
    -
    577  auto n = todo_.fetch_sub(1, mem::release) - 1;
    -
    578  if (n == 0) {
    -
    579  // all jobs are done; lock before signal to prevent spurious failure
    -
    580  {
    -
    581  std::lock_guard<std::mutex> lk{ mtx_ };
    -
    582  }
    -
    583  cv_.notify_all();
    -
    584  }
    -
    585  }
    -
    586 
    -
    587  void report_fail(std::exception_ptr err_ptr)
    -
    588  {
    -
    589  std::lock_guard<std::mutex> lk(mtx_);
    -
    590  if (has_errored()) // only catch first exception
    -
    591  return;
    -
    592  err_ptr_ = err_ptr;
    -
    593  status_ = Status::errored;
    -
    594 
    -
    595  // Some threads may change todo_ after we stop. The large
    -
    596  // negative number forces them to exit the processing loop.
    -
    597  todo_.store(std::numeric_limits<int>::min() / 2);
    -
    598  cv_.notify_all();
    -
    599  }
    -
    600 
    -
    601  void stop()
    -
    602  {
    -
    603  {
    -
    604  std::lock_guard<std::mutex> lk(mtx_);
    -
    605  status_ = Status::stopped;
    -
    606  }
    -
    607  // Worker threads wait on queue-specific mutex -> notify all queues.
    -
    608  for (auto& q : queues_)
    -
    609  q.stop();
    -
    610  }
    -
    611 
    -
    612  void rethrow_exception()
    -
    613  {
    -
    614  // Exceptions are only thrown from the owner thread, not in workers.
    -
    615  if (called_from_owner_thread() && has_errored()) {
    -
    616  {
    -
    617  // Wait for all threads to idle so we can clean up after them.
    -
    618  std::unique_lock<std::mutex> lk(mtx_);
    -
    619  cv_.wait(lk, [this] { return num_waiting_ == queues_.size(); });
    -
    620  }
    -
    621  // Before throwing: restore defaults for potential future use of
    -
    622  // the task manager.
    -
    623  todo_ = 0;
    -
    624  auto current_exception = err_ptr_;
    -
    625  err_ptr_ = nullptr;
    -
    626  status_ = Status::running;
    -
    627 
    -
    628  std::rethrow_exception(current_exception);
    -
    629  }
    -
    630  }
    -
    631 
    -
    632  bool is_running() const
    -
    633  {
    -
    634  return status_.load(mem::relaxed) == Status::running;
    -
    635  }
    -
    636 
    -
    637  bool has_errored() const
    -
    638  {
    -
    639  return status_.load(mem::relaxed) == Status::errored;
    -
    640  }
    -
    641 
    -
    642  bool stopped() const
    -
    643  {
    -
    644  return status_.load(mem::relaxed) == Status::stopped;
    -
    645  }
    -
    646 
    -
    647  bool done() const { return (todo_.load(mem::relaxed) <= 0); }
    -
    648 
    -
    649  private:
    -
    651  std::vector<TaskQueue> queues_;
    -
    652  size_t num_queues_;
    -
    653 
    -
    655  mem::relaxed_atomic<size_t> num_waiting_{ 0 };
    -
    656  mem::relaxed_atomic<size_t> push_idx_{ 0 };
    -
    657  mem::aligned_atomic<int> todo_{ 0 };
    -
    658 
    -
    660  const std::thread::id owner_id_;
    -
    661  enum class Status
    -
    662  {
    -
    663  running,
    -
    664  errored,
    -
    665  stopped
    -
    666  };
    -
    667  mem::aligned_atomic<Status> status_{ Status::running };
    -
    668  std::mutex mtx_;
    -
    669  std::condition_variable cv_;
    -
    670  std::exception_ptr err_ptr_{ nullptr };
    -
    671 };
    -
    672 
    -
    673 } // end namespace sched
    -
    674 
    -
    675 // 4. ------------------------------------------------------------------------
    -
    676 
    -
    678 class ThreadPool
    -
    679 {
    -
    680  public:
    -
    684  explicit ThreadPool(size_t threads = std::thread::hardware_concurrency())
    -
    685  : task_manager_{ threads }
    -
    686  {
    -
    687  set_active_threads(threads);
    -
    688  }
    -
    689 
    -
    690  ~ThreadPool()
    -
    691  {
    -
    692  task_manager_.stop();
    -
    693  join_threads();
    -
    694  }
    -
    695 
    -
    696  ThreadPool(ThreadPool&&) = delete;
    -
    697  ThreadPool(const ThreadPool&) = delete;
    -
    698  ThreadPool& operator=(const ThreadPool&) = delete;
    -
    699  ThreadPool& operator=(ThreadPool&& other) = delete;
    -
    700 
    -
    702  static ThreadPool& global_instance()
    -
    703  {
    -
    704 #ifdef _WIN32
    -
    705  // Must leak resource, because windows + R deadlock otherwise.
    -
    706  // Memory is released on shutdown.
    -
    707  static auto ptr = new ThreadPool;
    -
    708  return *ptr;
    -
    709 #else
    -
    710  static ThreadPool instance_;
    -
    711  return instance_;
    -
    712 #endif
    +
    569  void resize(size_t num_queues)
    +
    570  {
    +
    571  num_queues_ = std::max(num_queues, static_cast<size_t>(1));
    +
    572  if (num_queues > queues_.size()) {
    +
    573  queues_ = mem::aligned::vector<TaskQueue>(num_queues);
    +
    574  // thread pool must have stopped the manager, reset
    +
    575  num_waiting_ = 0;
    +
    576  todo_ = 0;
    +
    577  status_ = Status::running;
    +
    578  }
    +
    579  }
    +
    580 
    +
    581  template<typename Task>
    +
    582  void push(Task&& task)
    +
    583  {
    +
    584  rethrow_exception(); // push() throws if a task has errored.
    +
    585  if (is_running()) {
    +
    586  todo_.fetch_add(1, mem::release);
    +
    587  queues_[push_idx_++ % num_queues_].push(task);
    +
    588  }
    +
    589  }
    +
    590 
    +
    591  template<typename Task>
    +
    592  bool try_pop(Task& task, size_t worker_id = 0)
    +
    593  {
    +
    594  // Always start pop cycle at own queue to avoid contention.
    +
    595  for (size_t k = 0; k <= num_queues_; k++) {
    +
    596  if (queues_[(worker_id + k) % num_queues_].try_pop(task)) {
    +
    597  if (is_running()) {
    +
    598  return true;
    +
    599  } else {
    +
    600  // Throw away task if pool has stopped or errored.
    +
    601  return false;
    +
    602  }
    +
    603  }
    +
    604  }
    +
    605 
    +
    606  return false;
    +
    607  }
    +
    608 
    +
    609  void wake_up_all_workers()
    +
    610  {
    +
    611  for (auto& q : queues_)
    +
    612  q.wake_up();
    +
    613  }
    +
    614 
    +
    615  void wait_for_jobs(size_t id)
    +
    616  {
    +
    617  if (has_errored()) {
    +
    618  // Main thread may be waiting to reset the pool.
    +
    619  std::lock_guard<std::mutex> lk(mtx_);
    +
    620  if (++num_waiting_ == queues_.size())
    +
    621  cv_.notify_all();
    +
    622  } else {
    +
    623  ++num_waiting_;
    +
    624  }
    +
    625 
    +
    626  queues_[id].wait();
    +
    627  --num_waiting_;
    +
    628  }
    +
    629 
    +
    631  void wait_for_finish(size_t millis = 0)
    +
    632  {
    +
    633  if (called_from_owner_thread() && is_running()) {
    +
    634  auto wake_up = [this] { return (todo_ <= 0) || !is_running(); };
    +
    635  std::unique_lock<std::mutex> lk(mtx_);
    +
    636  if (millis == 0) {
    +
    637  cv_.wait(lk, wake_up);
    +
    638  } else {
    +
    639  cv_.wait_for(lk, std::chrono::milliseconds(millis), wake_up);
    +
    640  }
    +
    641  }
    +
    642  rethrow_exception();
    +
    643  }
    +
    644 
    +
    645  bool called_from_owner_thread() const
    +
    646  {
    +
    647  return (std::this_thread::get_id() == owner_id_);
    +
    648  }
    +
    649 
    +
    650  void report_success()
    +
    651  {
    +
    652 
    +
    653  auto n = todo_.fetch_sub(1, mem::release) - 1;
    +
    654  if (n == 0) {
    +
    655  // all jobs are done; lock before signal to prevent spurious
    +
    656  // failure
    +
    657  {
    +
    658  std::lock_guard<std::mutex> lk{ mtx_ };
    +
    659  }
    +
    660  cv_.notify_all();
    +
    661  }
    +
    662  }
    +
    663 
    +
    664  void report_fail(std::exception_ptr err_ptr)
    +
    665  {
    +
    666  std::lock_guard<std::mutex> lk(mtx_);
    +
    667  if (has_errored()) // only catch first exception
    +
    668  return;
    +
    669  err_ptr_ = err_ptr;
    +
    670  status_ = Status::errored;
    +
    671 
    +
    672  // Some threads may change todo_ after we stop. The large
    +
    673  // negative number forces them to exit the processing loop.
    +
    674  todo_.store(std::numeric_limits<int>::min() / 2);
    +
    675  cv_.notify_all();
    +
    676  }
    +
    677 
    +
    678  void stop()
    +
    679  {
    +
    680  {
    +
    681  std::lock_guard<std::mutex> lk(mtx_);
    +
    682  status_ = Status::stopped;
    +
    683  }
    +
    684  // Worker threads wait on queue-specific mutex -> notify all queues.
    +
    685  for (auto& q : queues_)
    +
    686  q.stop();
    +
    687  }
    +
    688 
    +
    689  void rethrow_exception()
    +
    690  {
    +
    691  // Exceptions are only thrown from the owner thread, not in workers.
    +
    692  if (called_from_owner_thread() && has_errored()) {
    +
    693  {
    +
    694  // Wait for all threads to idle so we can clean up after
    +
    695  // them.
    +
    696  std::unique_lock<std::mutex> lk(mtx_);
    +
    697  cv_.wait(lk, [this] { return num_waiting_ == queues_.size(); });
    +
    698  }
    +
    699  // Before throwing: restore defaults for potential future use of
    +
    700  // the task manager.
    +
    701  todo_ = 0;
    +
    702  auto current_exception = err_ptr_;
    +
    703  err_ptr_ = nullptr;
    +
    704  status_ = Status::running;
    +
    705 
    +
    706  std::rethrow_exception(current_exception);
    +
    707  }
    +
    708  }
    +
    709 
    +
    710  bool is_running() const
    +
    711  {
    +
    712  return status_.load(mem::relaxed) == Status::running;
    713  }
    714 
    -
    718  void set_active_threads(size_t threads)
    -
    719  {
    -
    720  if (!task_manager_.called_from_owner_thread())
    -
    721  return;
    -
    722 
    -
    723  if (threads <= workers_.size()) {
    -
    724  task_manager_.resize(threads);
    -
    725  } else {
    -
    726  if (workers_.size() > 0) {
    -
    727  task_manager_.stop();
    -
    728  join_threads();
    -
    729  }
    -
    730  workers_ = std::vector<std::thread>{ threads };
    -
    731  task_manager_.resize(threads);
    -
    732  for (size_t id = 0; id < threads; ++id) {
    -
    733  add_worker(id);
    -
    734  }
    -
    735  }
    -
    736  active_threads_ = threads;
    -
    737  }
    -
    738 
    -
    740  size_t get_active_threads() const { return active_threads_; }
    -
    741 
    -
    745  template<class Function, class... Args>
    -
    746  void push(Function&& f, Args&&... args)
    -
    747  {
    -
    748  if (active_threads_ == 0)
    -
    749  return f(args...);
    -
    750  task_manager_.push(
    -
    751  std::bind(std::forward<Function>(f), std::forward<Args>(args)...));
    -
    752  }
    -
    753 
    -
    759  template<class Function, class... Args>
    -
    760  auto async(Function&& f, Args&&... args)
    -
    761  -> std::future<decltype(f(args...))>
    -
    762  {
    -
    763  auto pack =
    -
    764  std::bind(std::forward<Function>(f), std::forward<Args>(args)...);
    -
    765  using pack_t = std::packaged_task<decltype(f(args...))()>;
    -
    766  auto task_ptr = std::make_shared<pack_t>(std::move(pack));
    -
    767  this->push([task_ptr] { (*task_ptr)(); });
    -
    768  return task_ptr->get_future();
    -
    769  }
    -
    770 
    -
    780  template<class UnaryFunction>
    -
    781  void parallel_for(int begin, int end, UnaryFunction f)
    -
    782  {
    -
    783  // each worker has its dedicated range, but can steal part of
    -
    784  // another worker's ranges when done with own
    -
    785  auto n = std::min(end - begin, static_cast<int>(1));
    -
    786  auto workers = loop::create_workers<UnaryFunction>(f, begin, end, n);
    -
    787  for (int k = 0; k < n; k++) {
    -
    788  this->push([=] { workers->at(k).run(workers); });
    -
    789  }
    -
    790  this->wait();
    +
    715  bool has_errored() const
    +
    716  {
    +
    717  return status_.load(mem::relaxed) == Status::errored;
    +
    718  }
    +
    719 
    +
    720  bool stopped() const
    +
    721  {
    +
    722  return status_.load(mem::relaxed) == Status::stopped;
    +
    723  }
    +
    724 
    +
    725  bool done() const { return (todo_.load(mem::relaxed) <= 0); }
    +
    726 
    +
    727  private:
    +
    729  mem::aligned::vector<TaskQueue> queues_;
    +
    730  size_t num_queues_;
    +
    731 
    +
    733  mem::aligned::relaxed_atomic<size_t> num_waiting_{ 0 };
    +
    734  mem::aligned::relaxed_atomic<size_t> push_idx_{ 0 };
    +
    735  mem::aligned::atomic<int> todo_{ 0 };
    +
    736 
    +
    738  const std::thread::id owner_id_;
    +
    739  enum class Status
    +
    740  {
    +
    741  running,
    +
    742  errored,
    +
    743  stopped
    +
    744  };
    +
    745  mem::aligned::atomic<Status> status_{ Status::running };
    +
    746  std::mutex mtx_;
    +
    747  std::condition_variable cv_;
    +
    748  std::exception_ptr err_ptr_{ nullptr };
    +
    749 };
    +
    750 
    +
    751 } // end namespace sched
    +
    752 
    +
    753 // 4. ------------------------------------------------------------------------
    +
    754 
    +
    756 class ThreadPool
    +
    757 {
    +
    758  public:
    +
    762  explicit ThreadPool(size_t threads = std::thread::hardware_concurrency())
    +
    763  : task_manager_{ threads }
    +
    764  {
    +
    765  set_active_threads(threads);
    +
    766  }
    +
    767 
    +
    768  ~ThreadPool()
    +
    769  {
    +
    770  task_manager_.stop();
    +
    771  join_threads();
    +
    772  }
    +
    773 
    +
    774  ThreadPool(ThreadPool&&) = delete;
    +
    775  ThreadPool(const ThreadPool&) = delete;
    +
    776  ThreadPool& operator=(const ThreadPool&) = delete;
    +
    777  ThreadPool& operator=(ThreadPool&& other) = delete;
    +
    778 
    +
    780  static ThreadPool& global_instance()
    +
    781  {
    +
    782 #ifdef _WIN32
    +
    783  // Must leak resource, because windows + R deadlock otherwise.
    +
    784  // Memory is released on shutdown.
    +
    785  static auto ptr = new ThreadPool;
    +
    786  return *ptr;
    +
    787 #else
    +
    788  static ThreadPool instance_;
    +
    789  return instance_;
    +
    790 #endif
    791  }
    792 
    -
    802  template<class Items, class UnaryFunction>
    -
    803  inline void parallel_for_each(Items& items, UnaryFunction f)
    -
    804  {
    -
    805  auto begin = std::begin(items);
    -
    806  auto size = std::distance(begin, std::end(items));
    -
    807  this->parallel_for(0, size, [=](int i) { f(begin[i]); });
    -
    808  }
    -
    809 
    -
    814  void wait(size_t millis = 0) { task_manager_.wait_for_finish(millis); }
    -
    815 
    -
    817  bool done() const { return task_manager_.done(); }
    -
    818 
    -
    819  private:
    -
    821  void join_threads()
    -
    822  {
    -
    823  for (auto& worker : workers_) {
    -
    824  if (worker.joinable())
    -
    825  worker.join();
    -
    826  }
    -
    827  }
    -
    828 
    -
    831  void add_worker(size_t id)
    -
    832  {
    -
    833  workers_[id] = std::thread([&, id] {
    -
    834  std::function<void()> task;
    -
    835  while (!task_manager_.stopped()) {
    -
    836  task_manager_.wait_for_jobs(id);
    -
    837  do {
    -
    838  // inner while to save some time calling done()
    -
    839  while (task_manager_.try_pop(task, id))
    -
    840  this->execute_safely(task);
    -
    841  } while (!task_manager_.done());
    -
    842  }
    -
    843  });
    -
    844 
    -
    845  // set thread affinity on linux
    -
    846  this->set_thread_affinity(id);
    +
    796  void set_active_threads(size_t threads)
    +
    797  {
    +
    798  if (!task_manager_.called_from_owner_thread())
    +
    799  return;
    +
    800 
    +
    801  if (threads <= workers_.size()) {
    +
    802  task_manager_.resize(threads);
    +
    803  } else {
    +
    804  if (workers_.size() > 0) {
    +
    805  task_manager_.stop();
    +
    806  join_threads();
    +
    807  }
    +
    808  workers_ = std::vector<std::thread>{ threads };
    +
    809  task_manager_ = quickpool::sched::TaskManager{ threads };
    +
    810  for (size_t id = 0; id < threads; ++id) {
    +
    811  add_worker(id);
    +
    812  }
    +
    813  }
    +
    814  active_threads_ = threads;
    +
    815  }
    +
    816 
    +
    818  size_t get_active_threads() const { return active_threads_; }
    +
    819 
    +
    823  template<class Function, class... Args>
    +
    824  void push(Function&& f, Args&&... args)
    +
    825  {
    +
    826  if (active_threads_ == 0)
    +
    827  return f(args...);
    +
    828  task_manager_.push(
    +
    829  std::bind(std::forward<Function>(f), std::forward<Args>(args)...));
    +
    830  }
    +
    831 
    +
    837  template<class Function, class... Args>
    +
    838  auto async(Function&& f, Args&&... args)
    +
    839  -> std::future<decltype(f(args...))>
    +
    840  {
    +
    841  auto pack =
    +
    842  std::bind(std::forward<Function>(f), std::forward<Args>(args)...);
    +
    843  using pack_t = std::packaged_task<decltype(f(args...))()>;
    +
    844  auto task_ptr = std::make_shared<pack_t>(std::move(pack));
    +
    845  this->push([task_ptr] { (*task_ptr)(); });
    +
    846  return task_ptr->get_future();
    847  }
    848 
    -
    851  void set_thread_affinity(size_t id)
    -
    852  {
    -
    853 #if (defined __linux__ || defined AFFINITY)
    -
    854  auto hardware_cores = std::thread::hardware_concurrency();
    -
    855  if (id >= hardware_cores)
    -
    856  id = id % hardware_cores;
    -
    857  cpu_set_t cpuset;
    -
    858  CPU_ZERO(&cpuset);
    -
    859  CPU_SET(id, &cpuset);
    -
    860  int rc = pthread_setaffinity_np(
    -
    861  workers_.at(id).native_handle(), sizeof(cpu_set_t), &cpuset);
    -
    862  if (rc != 0) {
    -
    863  throw std::runtime_error("Error calling pthread_setaffinity_np");
    -
    864  }
    -
    865 #endif
    -
    866  }
    -
    867 
    -
    868  void execute_safely(std::function<void()>& task)
    -
    869  {
    -
    870  try {
    -
    871  task();
    -
    872  task_manager_.report_success();
    -
    873  } catch (...) {
    -
    874  task_manager_.report_fail(std::current_exception());
    -
    875  }
    -
    876  }
    -
    877 
    -
    878  sched::TaskManager task_manager_;
    -
    879  std::vector<std::thread> workers_;
    -
    880  std::atomic_size_t active_threads_;
    -
    881 };
    -
    882 
    -
    883 // 5. ---------------------------------------------------
    -
    884 
    -
    886 
    -
    890 template<class Function, class... Args>
    -
    891 inline void
    -
    892 push(Function&& f, Args&&... args)
    -
    893 {
    -
    894  ThreadPool::global_instance().push(std::forward<Function>(f),
    -
    895  std::forward<Args>(args)...);
    -
    896 }
    -
    897 
    -
    903 template<class Function, class... Args>
    -
    904 inline auto
    -
    905 async(Function&& f, Args&&... args) -> std::future<decltype(f(args...))>
    -
    906 {
    -
    907  return ThreadPool::global_instance().async(std::forward<Function>(f),
    -
    908  std::forward<Args>(args)...);
    -
    909 }
    -
    910 
    -
    913 inline void
    -
    914 wait()
    -
    915 {
    -
    916  ThreadPool::global_instance().wait();
    -
    917 }
    -
    918 
    -
    920 inline bool
    -
    921 done()
    -
    922 {
    -
    923  return ThreadPool::global_instance().done();
    -
    924 }
    -
    925 
    -
    929 inline void
    -
    930 set_active_threads(size_t threads)
    -
    931 {
    -
    932  ThreadPool::global_instance().set_active_threads(threads);
    -
    933 }
    -
    934 
    -
    937 inline size_t
    -
    938 get_active_threads()
    -
    939 {
    -
    940  return ThreadPool::global_instance().get_active_threads();
    -
    941 }
    -
    942 
    -
    952 template<class UnaryFunction>
    -
    953 inline void
    -
    954 parallel_for(int begin, int end, UnaryFunction&& f)
    -
    955 {
    -
    956  ThreadPool::global_instance().parallel_for(
    -
    957  begin, end, std::forward<UnaryFunction>(f));
    -
    958 }
    -
    959 
    -
    969 template<class Items, class UnaryFunction>
    -
    970 inline void
    -
    971 parallel_for_each(Items& items, UnaryFunction&& f)
    -
    972 {
    -
    973  ThreadPool::global_instance().parallel_for_each(
    -
    974  items, std::forward<UnaryFunction>(f));
    -
    975 }
    -
    976 
    -
    977 } // end namespace quickpool
    +
    858  template<class UnaryFunction>
    +
    859  void parallel_for(int begin, int end, UnaryFunction f)
    +
    860  {
    +
    861  // each worker has its dedicated range, but can steal part of
    +
    862  // another worker's ranges when done with own
    +
    863  auto n = std::min(end - begin, static_cast<int>(1));
    +
    864  auto workers = loop::create_workers<UnaryFunction>(f, begin, end, n);
    +
    865  for (int k = 0; k < n; k++) {
    +
    866  this->push([=] { workers->at(k).run(workers); });
    +
    867  }
    +
    868  this->wait();
    +
    869  }
    +
    870 
    +
    880  template<class Items, class UnaryFunction>
    +
    881  inline void parallel_for_each(Items& items, UnaryFunction f)
    +
    882  {
    +
    883  auto begin = std::begin(items);
    +
    884  auto size = std::distance(begin, std::end(items));
    +
    885  this->parallel_for(0, size, [=](int i) { f(begin[i]); });
    +
    886  }
    +
    887 
    +
    892  void wait(size_t millis = 0) { task_manager_.wait_for_finish(millis); }
    +
    893 
    +
    895  bool done() const { return task_manager_.done(); }
    +
    896 
    +
    898  static void* operator new(size_t count) noexcept
    +
    899  {
    +
    900  return mem::aligned::alloc(alignof(ThreadPool), count);
    +
    901  }
    +
    902 
    +
    904  static void operator delete(void* ptr) { mem::aligned::free(ptr); }
    +
    905 
    +
    906  private:
    +
    908  void join_threads()
    +
    909  {
    +
    910  for (auto& worker : workers_) {
    +
    911  if (worker.joinable())
    +
    912  worker.join();
    +
    913  }
    +
    914  }
    +
    915 
    +
    918  void add_worker(size_t id)
    +
    919  {
    +
    920  workers_[id] = std::thread([&, id] {
    +
    921  std::function<void()> task;
    +
    922  while (!task_manager_.stopped()) {
    +
    923  task_manager_.wait_for_jobs(id);
    +
    924  do {
    +
    925  // inner while to save some time calling done()
    +
    926  while (task_manager_.try_pop(task, id))
    +
    927  this->execute_safely(task);
    +
    928  } while (!task_manager_.done());
    +
    929  }
    +
    930  });
    +
    931 
    +
    932  // set thread affinity on linux
    +
    933  this->set_thread_affinity(id);
    +
    934  }
    +
    935 
    +
    938  void set_thread_affinity(size_t id)
    +
    939  {
    +
    940 #if (defined __linux__ || defined AFFINITY)
    +
    941  auto hardware_cores = std::thread::hardware_concurrency();
    +
    942  if (id >= hardware_cores)
    +
    943  id = id % hardware_cores;
    +
    944  cpu_set_t cpuset;
    +
    945  CPU_ZERO(&cpuset);
    +
    946  CPU_SET(id, &cpuset);
    +
    947  int rc = pthread_setaffinity_np(
    +
    948  workers_.at(id).native_handle(), sizeof(cpu_set_t), &cpuset);
    +
    949  if (rc != 0) {
    +
    950  throw std::runtime_error("Error calling pthread_setaffinity_np");
    +
    951  }
    +
    952 #endif
    +
    953  }
    +
    954 
    +
    955  void execute_safely(std::function<void()>& task)
    +
    956  {
    +
    957  try {
    +
    958  task();
    +
    959  task_manager_.report_success();
    +
    960  } catch (...) {
    +
    961  task_manager_.report_fail(std::current_exception());
    +
    962  }
    +
    963  }
    +
    964 
    +
    965  sched::TaskManager task_manager_;
    +
    966  std::vector<std::thread> workers_;
    +
    967  std::atomic_size_t active_threads_;
    +
    968 };
    +
    969 
    +
    970 // 5. ---------------------------------------------------
    +
    971 
    +
    973 
    +
    977 template<class Function, class... Args>
    +
    978 inline void
    +
    979 push(Function&& f, Args&&... args)
    +
    980 {
    +
    981  ThreadPool::global_instance().push(std::forward<Function>(f),
    +
    982  std::forward<Args>(args)...);
    +
    983 }
    +
    984 
    +
    990 template<class Function, class... Args>
    +
    991 inline auto
    +
    992 async(Function&& f, Args&&... args) -> std::future<decltype(f(args...))>
    +
    993 {
    +
    994  return ThreadPool::global_instance().async(std::forward<Function>(f),
    +
    995  std::forward<Args>(args)...);
    +
    996 }
    +
    997 
    +
    1000 inline void
    +
    1001 wait()
    +
    1002 {
    +
    1003  ThreadPool::global_instance().wait();
    +
    1004 }
    +
    1005 
    +
    1007 inline bool
    +
    1008 done()
    +
    1009 {
    +
    1010  return ThreadPool::global_instance().done();
    +
    1011 }
    +
    1012 
    +
    1016 inline void
    +
    1017 set_active_threads(size_t threads)
    +
    1018 {
    +
    1019  ThreadPool::global_instance().set_active_threads(threads);
    +
    1020 }
    +
    1021 
    +
    1024 inline size_t
    +
    1025 get_active_threads()
    +
    1026 {
    +
    1027  return ThreadPool::global_instance().get_active_threads();
    +
    1028 }
    +
    1029 
    +
    1039 template<class UnaryFunction>
    +
    1040 inline void
    +
    1041 parallel_for(int begin, int end, UnaryFunction&& f)
    +
    1042 {
    +
    1043  ThreadPool::global_instance().parallel_for(
    +
    1044  begin, end, std::forward<UnaryFunction>(f));
    +
    1045 }
    +
    1046 
    +
    1056 template<class Items, class UnaryFunction>
    +
    1057 inline void
    +
    1058 parallel_for_each(Items& items, UnaryFunction&& f)
    +
    1059 {
    +
    1060  ThreadPool::global_instance().parallel_for_each(
    +
    1061  items, std::forward<UnaryFunction>(f));
    +
    1062 }
    +
    1063 
    +
    1064 } // end namespace quickpool
    -
    quickpool::get_active_threads
    size_t get_active_threads()
    retrieves the number of active worker threads in the global thread pool.
    Definition: quickpool.hpp:938
    -
    quickpool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction &&f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:954
    -
    quickpool::set_active_threads
    void set_active_threads(size_t threads)
    sets the number of active worker threads in the global thread pool.
    Definition: quickpool.hpp:930
    -
    quickpool
    quickpool namespace
    Definition: quickpool.hpp:55
    -
    quickpool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction &&f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:971
    -
    quickpool::ThreadPool::get_active_threads
    size_t get_active_threads() const
    retrieves the number of active worker threads in the thread pool.
    Definition: quickpool.hpp:740
    -
    quickpool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously the global thread pool.
    Definition: quickpool.hpp:905
    -
    quickpool::ThreadPool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:781
    -
    quickpool::done
    bool done()
    checks whether all globel jobs are done.
    Definition: quickpool.hpp:921
    -
    quickpool::ThreadPool::wait
    void wait(size_t millis=0)
    waits for all jobs currently running on the thread pool. Has no effect when called from threads other...
    Definition: quickpool.hpp:814
    -
    quickpool::ThreadPool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:803
    -
    quickpool::ThreadPool::global_instance
    static ThreadPool & global_instance()
    returns a reference to the global thread pool instance.
    Definition: quickpool.hpp:702
    -
    quickpool::ThreadPool::done
    bool done() const
    checks whether all jobs are done.
    Definition: quickpool.hpp:817
    -
    quickpool::wait
    void wait()
    waits for all jobs currently running on the global thread pool. Has no effect when not called from ma...
    Definition: quickpool.hpp:914
    -
    quickpool::ThreadPool::ThreadPool
    ThreadPool(size_t threads=std::thread::hardware_concurrency())
    constructs a thread pool.
    Definition: quickpool.hpp:684
    -
    quickpool::ThreadPool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously on the global thread pool.
    Definition: quickpool.hpp:760
    -
    quickpool::ThreadPool::set_active_threads
    void set_active_threads(size_t threads)
    sets the number of active worker threads in the thread pool.
    Definition: quickpool.hpp:718
    -
    quickpool::ThreadPool
    A work stealing thread pool.
    Definition: quickpool.hpp:678
    -
    quickpool::ThreadPool::push
    void push(Function &&f, Args &&... args)
    pushes a job to the thread pool.
    Definition: quickpool.hpp:746
    -
    quickpool::push
    void push(Function &&f, Args &&... args)
    Free-standing functions (main API)
    Definition: quickpool.hpp:892
    +
    quickpool::get_active_threads
    size_t get_active_threads()
    retrieves the number of active worker threads in the global thread pool.
    Definition: quickpool.hpp:1025
    +
    quickpool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction &&f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:1041
    +
    quickpool::set_active_threads
    void set_active_threads(size_t threads)
    sets the number of active worker threads in the global thread pool.
    Definition: quickpool.hpp:1017
    +
    quickpool
    quickpool namespace
    Definition: quickpool.hpp:57
    +
    quickpool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction &&f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:1058
    +
    quickpool::ThreadPool::get_active_threads
    size_t get_active_threads() const
    retrieves the number of active worker threads in the thread pool.
    Definition: quickpool.hpp:818
    +
    quickpool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously the global thread pool.
    Definition: quickpool.hpp:992
    +
    quickpool::ThreadPool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:859
    +
    quickpool::done
    bool done()
    checks whether all globel jobs are done.
    Definition: quickpool.hpp:1008
    +
    quickpool::ThreadPool::wait
    void wait(size_t millis=0)
    waits for all jobs currently running on the thread pool. Has no effect when called from threads other...
    Definition: quickpool.hpp:892
    +
    quickpool::ThreadPool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:881
    +
    quickpool::ThreadPool::global_instance
    static ThreadPool & global_instance()
    returns a reference to the global thread pool instance.
    Definition: quickpool.hpp:780
    +
    quickpool::ThreadPool::done
    bool done() const
    checks whether all jobs are done.
    Definition: quickpool.hpp:895
    +
    quickpool::wait
    void wait()
    waits for all jobs currently running on the global thread pool. Has no effect when not called from ma...
    Definition: quickpool.hpp:1001
    +
    quickpool::ThreadPool::ThreadPool
    ThreadPool(size_t threads=std::thread::hardware_concurrency())
    constructs a thread pool.
    Definition: quickpool.hpp:762
    +
    quickpool::ThreadPool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously on the global thread pool.
    Definition: quickpool.hpp:838
    +
    quickpool::ThreadPool::set_active_threads
    void set_active_threads(size_t threads)
    sets the number of active worker threads in the thread pool.
    Definition: quickpool.hpp:796
    +
    quickpool::ThreadPool
    A work stealing thread pool.
    Definition: quickpool.hpp:756
    +
    quickpool::ThreadPool::push
    void push(Function &&f, Args &&... args)
    pushes a job to the thread pool.
    Definition: quickpool.hpp:824
    +
    quickpool::push
    void push(Function &&f, Args &&... args)
    Free-standing functions (main API)
    Definition: quickpool.hpp:979
    Generated by   diff --git a/docs/search/all_3.js b/docs/search/all_3.js index 50f81e7..368fcae 100644 --- a/docs/search/all_3.js +++ b/docs/search/all_3.js @@ -1,6 +1,5 @@ var searchData= [ - ['parallel_5ffor_4',['parallel_for',['../classquickpool_1_1ThreadPool.html#acb9d7efe2053b8d961ed98bcc2cf2618',1,'quickpool::ThreadPool::parallel_for()'],['../namespacequickpool.html#a3432dfdfadaf9705389263e726926b28',1,'quickpool::parallel_for()']]], - ['parallel_5ffor_5feach_5',['parallel_for_each',['../classquickpool_1_1ThreadPool.html#ad08862259cb77c023523789c0632a6f7',1,'quickpool::ThreadPool::parallel_for_each()'],['../namespacequickpool.html#a5542d71824605f77ed621c725d77ed69',1,'quickpool::parallel_for_each()']]], - ['push_6',['push',['../classquickpool_1_1ThreadPool.html#a3a79d3a078643e271b238ee1be47986e',1,'quickpool::ThreadPool::push()'],['../namespacequickpool.html#a06e138ab2370dc5055a64995ad6c9286',1,'quickpool::push()']]] + ['operator_20delete_4',['operator delete',['../classquickpool_1_1ThreadPool.html#a6c1369433f01eb78516e809a98aa1fb6',1,'quickpool::ThreadPool']]], + ['operator_20new_5',['operator new',['../classquickpool_1_1ThreadPool.html#a27bc3249d258543c450f0e98492be310',1,'quickpool::ThreadPool']]] ]; diff --git a/docs/search/all_4.js b/docs/search/all_4.js index 1a08838..332ca69 100644 --- a/docs/search/all_4.js +++ b/docs/search/all_4.js @@ -1,5 +1,6 @@ var searchData= [ - ['quickpool_7',['quickpool',['../index.html',1,'']]], - ['quickpool_8',['quickpool',['../namespacequickpool.html',1,'']]] + ['parallel_5ffor_6',['parallel_for',['../classquickpool_1_1ThreadPool.html#acb9d7efe2053b8d961ed98bcc2cf2618',1,'quickpool::ThreadPool::parallel_for()'],['../namespacequickpool.html#a3432dfdfadaf9705389263e726926b28',1,'quickpool::parallel_for()']]], + ['parallel_5ffor_5feach_7',['parallel_for_each',['../classquickpool_1_1ThreadPool.html#ad08862259cb77c023523789c0632a6f7',1,'quickpool::ThreadPool::parallel_for_each()'],['../namespacequickpool.html#a5542d71824605f77ed621c725d77ed69',1,'quickpool::parallel_for_each()']]], + ['push_8',['push',['../classquickpool_1_1ThreadPool.html#a3a79d3a078643e271b238ee1be47986e',1,'quickpool::ThreadPool::push()'],['../namespacequickpool.html#a06e138ab2370dc5055a64995ad6c9286',1,'quickpool::push()']]] ]; diff --git a/docs/search/all_5.js b/docs/search/all_5.js index c69ccfd..c913539 100644 --- a/docs/search/all_5.js +++ b/docs/search/all_5.js @@ -1,4 +1,5 @@ var searchData= [ - ['set_5factive_5fthreads_9',['set_active_threads',['../classquickpool_1_1ThreadPool.html#aaed4dbfa25b36013a801d69709c0fb0d',1,'quickpool::ThreadPool::set_active_threads()'],['../namespacequickpool.html#a56d0ddf0c5f3dc5f4cf2ada1c8cde29a',1,'quickpool::set_active_threads()']]] + ['quickpool_9',['quickpool',['../index.html',1,'']]], + ['quickpool_10',['quickpool',['../namespacequickpool.html',1,'']]] ]; diff --git a/docs/search/all_6.js b/docs/search/all_6.js index 3148b0b..1a3d661 100644 --- a/docs/search/all_6.js +++ b/docs/search/all_6.js @@ -1,4 +1,4 @@ var searchData= [ - ['threadpool_10',['ThreadPool',['../classquickpool_1_1ThreadPool.html',1,'quickpool::ThreadPool'],['../classquickpool_1_1ThreadPool.html#ace792be7b69bb4e18c1770d898e84303',1,'quickpool::ThreadPool::ThreadPool()']]] + ['set_5factive_5fthreads_11',['set_active_threads',['../classquickpool_1_1ThreadPool.html#aaed4dbfa25b36013a801d69709c0fb0d',1,'quickpool::ThreadPool::set_active_threads()'],['../namespacequickpool.html#a56d0ddf0c5f3dc5f4cf2ada1c8cde29a',1,'quickpool::set_active_threads()']]] ]; diff --git a/docs/search/all_7.js b/docs/search/all_7.js index 76ed98c..6d26665 100644 --- a/docs/search/all_7.js +++ b/docs/search/all_7.js @@ -1,4 +1,4 @@ var searchData= [ - ['wait_11',['wait',['../classquickpool_1_1ThreadPool.html#a118c926c7a49a5ac952291e207c4f4b1',1,'quickpool::ThreadPool::wait()'],['../namespacequickpool.html#a2a7dcef03a6a02c06a999ef6f244a291',1,'quickpool::wait()']]] + ['threadpool_12',['ThreadPool',['../classquickpool_1_1ThreadPool.html',1,'quickpool::ThreadPool'],['../classquickpool_1_1ThreadPool.html#ace792be7b69bb4e18c1770d898e84303',1,'quickpool::ThreadPool::ThreadPool()']]] ]; diff --git a/docs/search/all_8.html b/docs/search/all_8.html new file mode 100644 index 0000000..cf2b5df --- /dev/null +++ b/docs/search/all_8.html @@ -0,0 +1,30 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/search/all_8.js b/docs/search/all_8.js new file mode 100644 index 0000000..d7119f4 --- /dev/null +++ b/docs/search/all_8.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['wait_13',['wait',['../classquickpool_1_1ThreadPool.html#a118c926c7a49a5ac952291e207c4f4b1',1,'quickpool::ThreadPool::wait()'],['../namespacequickpool.html#a2a7dcef03a6a02c06a999ef6f244a291',1,'quickpool::wait()']]] +]; diff --git a/docs/search/all_9.html b/docs/search/all_9.html new file mode 100644 index 0000000..690785a --- /dev/null +++ b/docs/search/all_9.html @@ -0,0 +1,30 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/search/all_9.js b/docs/search/all_9.js new file mode 100644 index 0000000..c0bd9e6 --- /dev/null +++ b/docs/search/all_9.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['threadpool_18',['ThreadPool',['../classquickpool_1_1ThreadPool.html',1,'quickpool::ThreadPool'],['../classquickpool_1_1ThreadPool.html#ace792be7b69bb4e18c1770d898e84303',1,'quickpool::ThreadPool::ThreadPool()']]] +]; diff --git a/docs/search/all_a.html b/docs/search/all_a.html new file mode 100644 index 0000000..f2f3d3a --- /dev/null +++ b/docs/search/all_a.html @@ -0,0 +1,30 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/search/all_a.js b/docs/search/all_a.js new file mode 100644 index 0000000..ace3cf2 --- /dev/null +++ b/docs/search/all_a.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['wait_19',['wait',['../classquickpool_1_1ThreadPool.html#a118c926c7a49a5ac952291e207c4f4b1',1,'quickpool::ThreadPool::wait()'],['../namespacequickpool.html#a2a7dcef03a6a02c06a999ef6f244a291',1,'quickpool::wait()']]] +]; diff --git a/docs/search/classes_0.js b/docs/search/classes_0.js index bc89354..6ca1bf1 100644 --- a/docs/search/classes_0.js +++ b/docs/search/classes_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['threadpool_12',['ThreadPool',['../classquickpool_1_1ThreadPool.html',1,'quickpool']]] + ['threadpool_14',['ThreadPool',['../classquickpool_1_1ThreadPool.html',1,'quickpool']]] ]; diff --git a/docs/search/classes_1.html b/docs/search/classes_1.html new file mode 100644 index 0000000..c7ff4b3 --- /dev/null +++ b/docs/search/classes_1.html @@ -0,0 +1,30 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/search/classes_1.js b/docs/search/classes_1.js new file mode 100644 index 0000000..02d1f16 --- /dev/null +++ b/docs/search/classes_1.js @@ -0,0 +1,6 @@ +var searchData= +[ + ['padding_21',['padding',['../structquickpool_1_1padding__impl_1_1padding.html',1,'quickpool::padding_impl']]], + ['padding_3c_20t_2c_2064_20_3e_22',['padding< T, 64 >',['../structquickpool_1_1padding__impl_1_1padding.html',1,'quickpool::padding_impl']]], + ['padding_5fbytes_23',['padding_bytes',['../structquickpool_1_1padding__impl_1_1padding__bytes.html',1,'quickpool::padding_impl']]] +]; diff --git a/docs/search/classes_2.html b/docs/search/classes_2.html new file mode 100644 index 0000000..0d1e8a0 --- /dev/null +++ b/docs/search/classes_2.html @@ -0,0 +1,30 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/search/classes_2.js b/docs/search/classes_2.js new file mode 100644 index 0000000..a1e68d2 --- /dev/null +++ b/docs/search/classes_2.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['threadpool_24',['ThreadPool',['../classquickpool_1_1ThreadPool.html',1,'quickpool']]] +]; diff --git a/docs/search/functions_0.js b/docs/search/functions_0.js index 5c7d1b5..58ad5ca 100644 --- a/docs/search/functions_0.js +++ b/docs/search/functions_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['async_14',['async',['../classquickpool_1_1ThreadPool.html#af803164106b0c9181e01eb59bf9abdcc',1,'quickpool::ThreadPool::async()'],['../namespacequickpool.html#abe02477646e2dfceb9b8657815afefd1',1,'quickpool::async()']]] + ['async_16',['async',['../classquickpool_1_1ThreadPool.html#af803164106b0c9181e01eb59bf9abdcc',1,'quickpool::ThreadPool::async()'],['../namespacequickpool.html#abe02477646e2dfceb9b8657815afefd1',1,'quickpool::async()']]] ]; diff --git a/docs/search/functions_1.js b/docs/search/functions_1.js index cad295a..5c989bf 100644 --- a/docs/search/functions_1.js +++ b/docs/search/functions_1.js @@ -1,4 +1,4 @@ var searchData= [ - ['done_15',['done',['../classquickpool_1_1ThreadPool.html#ac0f882945e639b1092e543b11cf3abe8',1,'quickpool::ThreadPool::done()'],['../namespacequickpool.html#abc737ea3d3b4a958f05d435681d7098d',1,'quickpool::done()']]] + ['done_17',['done',['../classquickpool_1_1ThreadPool.html#ac0f882945e639b1092e543b11cf3abe8',1,'quickpool::ThreadPool::done()'],['../namespacequickpool.html#abc737ea3d3b4a958f05d435681d7098d',1,'quickpool::done()']]] ]; diff --git a/docs/search/functions_2.js b/docs/search/functions_2.js index f01ff7d..232d0ea 100644 --- a/docs/search/functions_2.js +++ b/docs/search/functions_2.js @@ -1,5 +1,5 @@ var searchData= [ - ['get_5factive_5fthreads_16',['get_active_threads',['../classquickpool_1_1ThreadPool.html#a9fa5b73a745b2382fecfadd2afb34735',1,'quickpool::ThreadPool::get_active_threads()'],['../namespacequickpool.html#a7e1597aaed04ba7dddb4e5beb0e3be63',1,'quickpool::get_active_threads()']]], - ['global_5finstance_17',['global_instance',['../classquickpool_1_1ThreadPool.html#ab5daa930caa3724dac002ac2dd3d3180',1,'quickpool::ThreadPool']]] + ['get_5factive_5fthreads_18',['get_active_threads',['../classquickpool_1_1ThreadPool.html#a9fa5b73a745b2382fecfadd2afb34735',1,'quickpool::ThreadPool::get_active_threads()'],['../namespacequickpool.html#a7e1597aaed04ba7dddb4e5beb0e3be63',1,'quickpool::get_active_threads()']]], + ['global_5finstance_19',['global_instance',['../classquickpool_1_1ThreadPool.html#ab5daa930caa3724dac002ac2dd3d3180',1,'quickpool::ThreadPool']]] ]; diff --git a/docs/search/functions_3.js b/docs/search/functions_3.js index 9343f8f..709f2b5 100644 --- a/docs/search/functions_3.js +++ b/docs/search/functions_3.js @@ -1,6 +1,5 @@ var searchData= [ - ['parallel_5ffor_18',['parallel_for',['../classquickpool_1_1ThreadPool.html#acb9d7efe2053b8d961ed98bcc2cf2618',1,'quickpool::ThreadPool::parallel_for()'],['../namespacequickpool.html#a3432dfdfadaf9705389263e726926b28',1,'quickpool::parallel_for()']]], - ['parallel_5ffor_5feach_19',['parallel_for_each',['../classquickpool_1_1ThreadPool.html#ad08862259cb77c023523789c0632a6f7',1,'quickpool::ThreadPool::parallel_for_each()'],['../namespacequickpool.html#a5542d71824605f77ed621c725d77ed69',1,'quickpool::parallel_for_each()']]], - ['push_20',['push',['../classquickpool_1_1ThreadPool.html#a3a79d3a078643e271b238ee1be47986e',1,'quickpool::ThreadPool::push()'],['../namespacequickpool.html#a06e138ab2370dc5055a64995ad6c9286',1,'quickpool::push()']]] + ['operator_20delete_20',['operator delete',['../classquickpool_1_1ThreadPool.html#a6c1369433f01eb78516e809a98aa1fb6',1,'quickpool::ThreadPool']]], + ['operator_20new_21',['operator new',['../classquickpool_1_1ThreadPool.html#a27bc3249d258543c450f0e98492be310',1,'quickpool::ThreadPool']]] ]; diff --git a/docs/search/functions_4.js b/docs/search/functions_4.js index 2f606c8..7a6e86c 100644 --- a/docs/search/functions_4.js +++ b/docs/search/functions_4.js @@ -1,4 +1,6 @@ var searchData= [ - ['set_5factive_5fthreads_21',['set_active_threads',['../classquickpool_1_1ThreadPool.html#aaed4dbfa25b36013a801d69709c0fb0d',1,'quickpool::ThreadPool::set_active_threads()'],['../namespacequickpool.html#a56d0ddf0c5f3dc5f4cf2ada1c8cde29a',1,'quickpool::set_active_threads()']]] + ['parallel_5ffor_22',['parallel_for',['../classquickpool_1_1ThreadPool.html#acb9d7efe2053b8d961ed98bcc2cf2618',1,'quickpool::ThreadPool::parallel_for()'],['../namespacequickpool.html#a3432dfdfadaf9705389263e726926b28',1,'quickpool::parallel_for()']]], + ['parallel_5ffor_5feach_23',['parallel_for_each',['../classquickpool_1_1ThreadPool.html#ad08862259cb77c023523789c0632a6f7',1,'quickpool::ThreadPool::parallel_for_each()'],['../namespacequickpool.html#a5542d71824605f77ed621c725d77ed69',1,'quickpool::parallel_for_each()']]], + ['push_24',['push',['../classquickpool_1_1ThreadPool.html#a3a79d3a078643e271b238ee1be47986e',1,'quickpool::ThreadPool::push()'],['../namespacequickpool.html#a06e138ab2370dc5055a64995ad6c9286',1,'quickpool::push()']]] ]; diff --git a/docs/search/functions_5.js b/docs/search/functions_5.js index 8ef4d55..6381523 100644 --- a/docs/search/functions_5.js +++ b/docs/search/functions_5.js @@ -1,4 +1,4 @@ var searchData= [ - ['threadpool_22',['ThreadPool',['../classquickpool_1_1ThreadPool.html#ace792be7b69bb4e18c1770d898e84303',1,'quickpool::ThreadPool']]] + ['set_5factive_5fthreads_25',['set_active_threads',['../classquickpool_1_1ThreadPool.html#aaed4dbfa25b36013a801d69709c0fb0d',1,'quickpool::ThreadPool::set_active_threads()'],['../namespacequickpool.html#a56d0ddf0c5f3dc5f4cf2ada1c8cde29a',1,'quickpool::set_active_threads()']]] ]; diff --git a/docs/search/functions_6.js b/docs/search/functions_6.js index 7041e5a..e642c60 100644 --- a/docs/search/functions_6.js +++ b/docs/search/functions_6.js @@ -1,4 +1,4 @@ var searchData= [ - ['wait_23',['wait',['../classquickpool_1_1ThreadPool.html#a118c926c7a49a5ac952291e207c4f4b1',1,'quickpool::ThreadPool::wait()'],['../namespacequickpool.html#a2a7dcef03a6a02c06a999ef6f244a291',1,'quickpool::wait()']]] + ['threadpool_26',['ThreadPool',['../classquickpool_1_1ThreadPool.html#ace792be7b69bb4e18c1770d898e84303',1,'quickpool::ThreadPool']]] ]; diff --git a/docs/search/functions_7.html b/docs/search/functions_7.html new file mode 100644 index 0000000..7de3106 --- /dev/null +++ b/docs/search/functions_7.html @@ -0,0 +1,30 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/search/functions_7.js b/docs/search/functions_7.js new file mode 100644 index 0000000..5928475 --- /dev/null +++ b/docs/search/functions_7.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['wait_27',['wait',['../classquickpool_1_1ThreadPool.html#a118c926c7a49a5ac952291e207c4f4b1',1,'quickpool::ThreadPool::wait()'],['../namespacequickpool.html#a2a7dcef03a6a02c06a999ef6f244a291',1,'quickpool::wait()']]] +]; diff --git a/docs/search/functions_8.html b/docs/search/functions_8.html new file mode 100644 index 0000000..7422be2 --- /dev/null +++ b/docs/search/functions_8.html @@ -0,0 +1,30 @@ + + + + + + + + + +
    +
    Loading...
    +
    + +
    Searching...
    +
    No Matches
    + +
    + + diff --git a/docs/search/functions_8.js b/docs/search/functions_8.js new file mode 100644 index 0000000..3a2e825 --- /dev/null +++ b/docs/search/functions_8.js @@ -0,0 +1,4 @@ +var searchData= +[ + ['wait_39',['wait',['../classquickpool_1_1ThreadPool.html#a118c926c7a49a5ac952291e207c4f4b1',1,'quickpool::ThreadPool::wait()'],['../namespacequickpool.html#a2a7dcef03a6a02c06a999ef6f244a291',1,'quickpool::wait()']]] +]; diff --git a/docs/search/namespaces_0.js b/docs/search/namespaces_0.js index 30f35e6..48d7d87 100644 --- a/docs/search/namespaces_0.js +++ b/docs/search/namespaces_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['quickpool_13',['quickpool',['../namespacequickpool.html',1,'']]] + ['quickpool_15',['quickpool',['../namespacequickpool.html',1,'']]] ]; diff --git a/docs/search/pages_0.js b/docs/search/pages_0.js index 93e44cd..987b95a 100644 --- a/docs/search/pages_0.js +++ b/docs/search/pages_0.js @@ -1,4 +1,4 @@ var searchData= [ - ['quickpool_24',['quickpool',['../index.html',1,'']]] + ['quickpool_28',['quickpool',['../index.html',1,'']]] ]; diff --git a/docs/search/searchdata.js b/docs/search/searchdata.js index 535906f..436ebba 100644 --- a/docs/search/searchdata.js +++ b/docs/search/searchdata.js @@ -1,9 +1,9 @@ var indexSectionsWithContent = { - 0: "adgpqstw", + 0: "adgopqstw", 1: "t", 2: "q", - 3: "adgpstw", + 3: "adgopstw", 4: "q" }; diff --git a/docs/structquickpool_1_1padding__impl_1_1empty__struct.html b/docs/structquickpool_1_1padding__impl_1_1empty__struct.html new file mode 100644 index 0000000..b240bfb --- /dev/null +++ b/docs/structquickpool_1_1padding__impl_1_1empty__struct.html @@ -0,0 +1,88 @@ + + + + + + + +quickpool: quickpool::padding_impl::empty_struct Struct Reference + + + + + + + + + +     +
    +
    +
    quickpool::padding_impl::empty_struct Struct Reference
    +
    +
    +

    Detailed Description

    +
    +

    Definition at line 96 of file quickpool.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.17 +
    + + diff --git a/docs/structquickpool_1_1padding__impl_1_1padding.html b/docs/structquickpool_1_1padding__impl_1_1padding.html new file mode 100644 index 0000000..9c5e3ad --- /dev/null +++ b/docs/structquickpool_1_1padding__impl_1_1padding.html @@ -0,0 +1,112 @@ + + + + + + + +quickpool: quickpool::padding_impl::padding< T, Align > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    quickpool +  1.3.0 +
    +
    An easy-to-use, header-only work stealing thread pool in C++11
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    quickpool::padding_impl::padding< T, Align > Struct Template Reference
    +
    +
    + +

    #include <quickpool.hpp>

    +
    +Inheritance diagram for quickpool::padding_impl::padding< T, Align >:
    +
    +
    Inheritance graph
    + + + + +
    [legend]
    +
    +Collaboration diagram for quickpool::padding_impl::padding< T, Align >:
    +
    +
    Collaboration graph
    + + + + +
    [legend]
    +

    Detailed Description

    +

    template<class T, size_t Align>
    +struct quickpool::padding_impl::padding< T, Align >

    + +

    Class holding padding bytes is necessary. Classes can inherit from this to automically add padding if necessary.

    + +

    Definition at line 102 of file quickpool.hpp.

    +
    The documentation for this struct was generated from the following file: +
    + +
    +Generated by   +doxygen + 1.8.17 +
    + + diff --git a/docs/structquickpool_1_1padding__impl_1_1padding__bytes-members.html b/docs/structquickpool_1_1padding__impl_1_1padding__bytes-members.html new file mode 100644 index 0000000..7c6c5e9 --- /dev/null +++ b/docs/structquickpool_1_1padding__impl_1_1padding__bytes-members.html @@ -0,0 +1,88 @@ + + + + + + + +quickpool: Member List + + + + + + + + + +
    +
    + + + + + + +
    +
    quickpool +  1.3.0 +
    +
    An easy-to-use, header-only work stealing thread pool in C++11
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +
    quickpool::padding_impl::padding_bytes< T, Align > Member List
    +
    +
    + +

    This is the complete list of members for quickpool::padding_impl::padding_bytes< T, Align >, including all inherited members.

    + + + + +
    free_space (defined in quickpool::padding_impl::padding_bytes< T, Align >)quickpool::padding_impl::padding_bytes< T, Align >static
    padding_ (defined in quickpool::padding_impl::padding_bytes< T, Align >)quickpool::padding_impl::padding_bytes< T, Align >
    required (defined in quickpool::padding_impl::padding_bytes< T, Align >)quickpool::padding_impl::padding_bytes< T, Align >static
    + +
    +Generated by   +doxygen + 1.8.17 +
    + + diff --git a/docs/structquickpool_1_1padding__impl_1_1padding__bytes.html b/docs/structquickpool_1_1padding__impl_1_1padding__bytes.html new file mode 100644 index 0000000..3654f16 --- /dev/null +++ b/docs/structquickpool_1_1padding__impl_1_1padding__bytes.html @@ -0,0 +1,140 @@ + + + + + + + +quickpool: quickpool::padding_impl::padding_bytes< T, Align > Struct Template Reference + + + + + + + + + +
    +
    + + + + + + +
    +
    quickpool +  1.3.0 +
    +
    An easy-to-use, header-only work stealing thread pool in C++11
    +
    +
    + + + + + + + + +
    +
    + + +
    + +
    + + +
    +
    +
    +Public Attributes | +Static Public Attributes | +List of all members
    +
    +
    quickpool::padding_impl::padding_bytes< T, Align > Struct Template Reference
    +
    +
    + + + + +

    +Public Attributes

    +char padding_ [required]
     
    + + + + + +

    +Static Public Attributes

    static constexpr size_t free_space
     
    +static constexpr size_t required = free_space > 1 ? free_space : 1
     
    +

    Detailed Description

    +

    template<class T, size_t Align>
    +struct quickpool::padding_impl::padding_bytes< T, Align >

    + + +

    Definition at line 88 of file quickpool.hpp.

    +

    Member Data Documentation

    + +

    ◆ free_space

    + +
    +
    +
    +template<class T , size_t Align>
    + + + + + +
    + + + + +
    constexpr size_t quickpool::padding_impl::padding_bytes< T, Align >::free_space
    +     		+staticconstexpr
    +
    +Initial value:
    =
    +
    Align - mod(sizeof(std::atomic<T>), Align)
    +
    +

    Definition at line 90 of file quickpool.hpp.

    + +
    +
    +
    The documentation for this struct was generated from the following file: +
    +
    quickpool::padding_impl::mod
    constexpr size_t mod(size_t a, size_t b)
    constexpr modulo operator.
    Definition: quickpool.hpp:80
    + +
    +Generated by   +doxygen + 1.8.17 +
    + + diff --git a/docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.map b/docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.map new file mode 100644 index 0000000..44507cd --- /dev/null +++ b/docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.md5 b/docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.md5 new file mode 100644 index 0000000..1688abb --- /dev/null +++ b/docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.md5 @@ -0,0 +1 @@ +4970813b69f242bfd6a5e02d969131b0 \ No newline at end of file diff --git a/docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.png b/docs/structquickpool_1_1padding__impl_1_1padding__coll__graph.png new file mode 100644 index 0000000000000000000000000000000000000000..6d44860c29e657b05485fc399006879d2337bfc5 GIT binary patch literal 8925 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 literal 0 HcmV?d00001 diff --git a/docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.map b/docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.map new file mode 100644 index 0000000..44507cd --- /dev/null +++ b/docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.map @@ -0,0 +1,4 @@ + + + + diff --git a/docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.md5 b/docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.md5 new file mode 100644 index 0000000..1688abb --- /dev/null +++ b/docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.md5 @@ -0,0 +1 @@ +4970813b69f242bfd6a5e02d969131b0 \ No newline at end of file diff --git a/docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.png b/docs/structquickpool_1_1padding__impl_1_1padding__inherit__graph.png new file mode 100644 index 0000000000000000000000000000000000000000..6d44860c29e657b05485fc399006879d2337bfc5 GIT binary patch literal 8925 zcmZ{KbySpbvp-U>p_}jcPU%(bk?~-D2u*ykfO8&o{dBuMLKTJ z)O0E*NFg~^PqkNi5*<_blXsTw;^x$jJtQ!FrI1nfSWl;LrI5r3l#Z|cZTM3g)x9lQ zByq;Sf~1g3gzs9sL z?-`0zGBsTqH}o#b%M&*1`T+0oo7Xul%KRSnoaa%>_wV8h zlnK{c_63g4&N*tVns-MB2JSI4<7yAmR(;1bFP;1??6~qN@RMfxcUrlh!mM%i6xEUB2B5q604h?;A*`9rp zt3r=(_g<{J~)R zI-bj5asOm{u0hgeYo^S!-G{vcX%tjd1Qr{|+bkM{TX3knJ>`jXey*QdtE6~8zmuz6+|Of4-f;eM7vvobRL6f(uV z&UBD;geVV*hQdMu>8PL}TszmzDSm9}j~_n8_Up|_~TG7ymF^|y0)_{k?_5<~(CDe2jR?2P0+ne*81{pPxVc77fj8XCB7SEElGo|Bh%jVnAnTt5EUvuA9KjEqr5 zIXMbiT4Rlk82WxRq?!UmocikOB+^k^TekM>6jC$m#MqrZJ$!Pf zGRDo%&l`H3K-b^l<$VG#(AtXg-3)~aIPdx8U|8?*4jCK~K@=#HuExs4!?U@$85dq)u)VnWJ|@QTXv@Ie-Ca*_y11ANTl(|JC1rL&0nEpATbqL2Gj(+8F?xPX(gwzhus;6aVk+WY9}=%S*RN=iy_F?hVC<>$=I%(ytpXk&)E zt$tt0LaRr8g9`HVySlsQ>ODp8-zO2gF(^`5O4HQTWN&XT_-dAXLc7bn93Kx)L_}n9 zX{koPxS(L8!fIHnP-kIv^=Pp*w79s~{b;MEw)XJwkTemG=CvA<_}${dg73NC0@^;r zyvYye`fUj(C#S-qqVwaW$o^#E%)-JjWJlGU*9~IgQtwMIm`#{U3lyr*uwiy$LPuL$ zkcnw|>t|g?D75==9H-vRn>PVyHWn75qoRC}N(u@JIywn?d2E3)_I7s2kRn#pU5e5t z^Y(kAG}P2TT3cORUBA2Tx6RDV^!9F!73pR4lD!NnC}5B2tSB#+^}d1O>+7pmWy{IM zl`7%s=ImSvC+LTS*&ZAmjEIOJBqRjTGcVI2V^&5QilUa6wzi03?deJBq0^9o&F#M> zY;0^i{^4OD{@YPjgdY+yG(BBVROGoc-}JOVEBze-E+Yd&^YpY{NKp9Iz5V^i%E|*z zZ|2FSt2zIkxN=EKPr7ir-7r2d(5T@3#@1S{adrRtEwRs^KUX{adT2HMk9CAh`uC-R zFz?*C!_WVfQ8B_u+ld}XiPgv6TMk1Y2yY)fm}y*z4Grz8Ff117Q{nLZ`KCvdocbh6qP8{;LLzkg3nO)2F>S|~i3 zq4H@pA$d85t)y>y0&xD_W&2iq_xVOigVNN!yFMl(OTOtub(xrG>_*F!RoCMk<7dwj zV`5^0#hUTN{Feta731RK^7HeTUnW53w1wX|KRaWxeuoN;tfWX24ORE?Z1YOz8D>xIQi}ZpPjBa8E zj(ps90vx3;ZPS6s%FYgKHQ_X@pXu-4K0Db*lUKfd+wOn$x>RaT4zs9eU0|E!v5LMKx9byW7_ti;P+wj<}Q*Akgpe@#FoHmtm*y_Hf9McqH zVq&}Hj_948onPJYr^m-L4c@o21O){Z<>h@X`cp&&na6Q)Nsn&O(!PKHzNfeM<;$0P zdV0VIfNN#e<6N?`vNLA@!Vexi0MG*3e-y{zdU1BL)E)^e<_*lqcSvG|BzwRUo1#FNz1saJCdFd6$*d=LbF&*YWA8g}M3E!6AKF}vpPRt3I*74+-tcm zIbc~q#-j40t&M0+riz?KX(lo(i~t{>mzNii(WHD5UX2`2UhZOGKn))sAKJ~(a1OBc z$B!QmVwgP-1{FgoIWdnCiM9U3GfBQMO(<0JutYCGv_ok85A4G)gd(NQWceId7l z&+p#7`}k4U$mmmfc{w^rHmkWnyX2On*G)=FxSgD$B06enrHje7wzed}SAeUaso=Vz zqN3gxC#&;h`bY?y}5a-@=Wp$?|rPFXG|`hK84*%yeNy z;463_k|>0NoczOw50-qiZr2Wr$gGeqE-uitFkJqEQAlbl^va6)lP6D@W30^0nQi{b zP*5G9wsKWcLe3OdH53)ECgpzl@?Ir(iI%Z&khz!;OD&|Yrzb2t+;evkC*f5Y2%SFJ zWpN|BhCV9G`ck9-3VUc|B=CHZtOq$5I;ovE$lu zivP-$4QF^52wrF`^eiDsS6Jpp->{=x4 zDq%efsQ3~aOL3@7Rt&?c7ACM`vpqJ z3Y6)K7a#x+y7l$+@Cz9pvdr-<)Xsi$Eq7d1fhhqFg;^G7VhU(qdS~Z{SUu=o?u@Cc zs~f!LS(ZvCPw>LP%0RkzKV*9g@uKzEY{l=5-+VMPxklwB_l&aVd~vL0cJmnS7UodLz4)#rJtD9d?KnCqERZ$$Or~T>` zcUph$prwO@gKCm87WAs&{1BAb6HQHQ_D;Fp zCY)HeoZ+>Fg#}w%TQui_Nhh^(5D-FtB5ynBhK>$2_(W%CXDqH4Hfn}*&SVUgl}VSAlS@cSdK(m!F`U4~#RdHUPZ}>a2n`R%8Dlg5sz7)}vntRM`Q>J5dgViTvwEEqmd78NcFCOK+@Zz5QJoN5 z9WL}eh7y*VH6eiI0w!K1z=Pu3q_B=K_tvSUyiiMz;UcWe%Dy%(A7& z$b4B|2XiVZK3>s5IHG+CTs?3KurQ}V?T21-)kGe%#vsB}`#Lpx_DB4@!v}l1pYzw< zm)iCXy*(3B49>uE$w*tcU*LxeG_?l$>P29m>=^sJGNU$ii)k51hDc$-_BdT5ui^5d z4sG#|Bte;%>J$Q8ESgi7{k$LGmJFwXcKr-$qgbzs$b*vTFHkEH5s`u*$TMb4C}=p$T&|WeqdxmGrE@u*8VLK z-QK~$41_ZP4R^k(o`cT1d-txfu`!5SsRMcH!gD!i(y#cTpuCckXTahEy$%l#U-b@o zBXl5iYBpB*478Fy*HNP{7N|S|+!koFfppmkGJl9xs#&^m=Iw;wN?rq*`cLr9A(xavaTw7koju@SP;mq)3DvgO>+CGW9*}#;PkdVULJ88}fzwWj5#!7E@ zSQsA)r7+CCegS?u{Dxqvs0+wZCI*I#oSc=8XvUjFt1G=pI5;?#0{YjK--qd(^nf8d z+w0~A+mW804kQA8N7Qu>B_-vP#pJ^E{2O{;6`l|_E@<_rWI+a(d- zzKO*?l#k~d8X7u&gF(1@c<78RT`EdBGBP5Sfe^5nD79OV5lOj4Lz9=8850{DI7>S4 zn`!8RiOoJ_+GB8wc3L?p=N4`4aipXU8=H03%TVg-ni@|q93Z0}#dB?fk-v5g?AYMw zD8HZ}Hz%ij`Man_>@bBBWumu^JM+>&sBnMaEkQC~yQmw3I89dr!3>sCyY_K zX8DSqT)R3ud_Vz+%-BL(MO^o?LP8$O$Ta(8+Xu-;#xRN9+CG}|mb71#)6$BAoFb_g zm*nOEyu}jq{6foH2ooVK8~gx9gM^zAf{~|MS_)P7XlZDSw=;4DrCAldWr8`tmO=wF z38oFMIYALFqrmt0$&naw^6~I2I@BP1%~_%kSzI5hEv$q(j|&-hk+0cs-K73Jn*}y2 z;2N2lxF-;cO>%Q=BU5K^Y(D`W9*=-Pz1yGs+}zxhl%EjZSoEiI<_)C5enWjR(t<~XN)s~hPz*Sip87S8+ zaW_pJ9cps&fLbi+sEiB-$TLX-A?*aNi2Ly26XV9rjQ-#gaY&J%`OpNf8!!{kb%y}1 zOxp-{o*jrqf_aXJ==<(|B((xJ1uwkNrD)ou!lh%9+&4JEY)Rh?&urUzkV0 zoqJdJeoaQ7ogbUysbnVtV;<6M74vt**KnfryT_kVD(wf@jy&odVndcYx|>q*Gd1 zS;=Td>HK*}evi}A#KbQLpjN_l51@uc?vF~E#5rikxeBY8QmGt7X`B&^GMwJY$;rIN zf!Ou`o`i`ymsgOfd3v71Y=WV}@Zz=8yJ}QE33EzEM+YRX&jq47R;fHj>GVkevtFJICtdD}KadvR{3z?ezFJ3nCkidUmI4AE(u%U3o7u;u%)L~xkc6W7wPW+c!Dlb)xLYEv0oLpVS5yv|y|}o@bkRy}p4dN_-~MjP7e~zV zucpSoQg(E8aT(NBzS1mN*#ayY*_IDKPLryh7)7gTBFnq4IyQ^6NR3iC#ImdL*bs)Z5iEvQ{6ct!u1vc zr9{)eFBWw_az`xk2hnXF>ahFXK4b+b4A}l;ei(E@d&ph!#)52(RsMy&H@G!YecmP< zo6l4VT9ubi!xIvy@d6nZaehH`b}L5X59v15HA*3ZIT{2?>>g#?sXvt;C70dj)@1b# zOEuZQIJG30^pQ+U7k~&jntqcuhsnZ@0|YQQU%q^K`V_LzA~(oHA&h}T0cYxm1OQNG zegeqy_;D|&^Za}~u`jRYBp{8V4L3J61t-F!mYEgs35Oc@z6CiC?MOATYgm&}z}vUe z6BGXoQ9{BD>`&Gj0<9WWCtEb?4$Y2{F)yAlE%@=wWXh{FH zuh)HE-XtM=6EG>TA%NCjb8<5^HHEw&MTMJ#1KU;L)$BLG%bm&Q=0yl&(Mu44K-)qt z4}1xt4~Us7vfcgStR^{GAEbke%Mn-~u+UN~fB*i41gQp?|05q8D=QjO7FY*l^tMDC zo&E~tuE)q&xPSkClE6!u;eQTOLnA;E!n+dPulb-90pH8}C1i=SV3%@?g6tmxAlK8w zmk=gGA{m_m@CQ*RKnj3&qNKOP+ZI?4hFdb)i{svfdR0T_4n`5q1Zp!@VmLQ6vb}4?bAJypbk@`H@9eM@%l1P|NaF*3k#hg z%L<75ICU!^qDP3^giRYx=zfTe?R2^=rJ_PqRUR-2_D=F*_j*Ph!cS9M+pyX$y`q8~ zO&&eB#!-AjkpnBP)=$cAaCo@o`9q$qrF`tGSFieG;e-87Dl9C7{n(Dbl(_~H329($ zb#=1H>-D5p^;WjF0{r}DJc&~5rojQ9uCy?&aQIjfzAz3J!(Eif&;1M$R92Q;=HS4i z!YkG1cQ6vSu&8Ni7oFqoo#WYPYH3026g&{jETbjYa@iMEFaFO?N)0?Fl zeGVj9xW6}lNL6V_ytvhZQ&o#7SUXLPjXv#55MAPnvFej|HO?S> z!&I4Qjslpwp zt6~27E90=W6*{S(+Q0yiiqDDctt z!a%{I0Cuzx|HDQOun{COA1^P^4{gFrk8iJk65bFfG^o=;PKQviLv9>E214ri$3`s# zx7~4^Phf6g2@X4V;4f=yEQu={EgllL!(M={YW;e1Tt&jS9sBP0*Bg}K3bMDKRoT+T zbjp=49L7sE>|Co=rOxOhWhJ)0mDbPA&0SSirmms!5kf#PQhRBye}bW#pEnX07cX_1 zo1A=Sos>mwwNXpl5yene&Fz<(nhK4cBJ%p-;+^Y3suCwz`S}kQTR~B%CJU+i;Sfcq zVD4&TGnSt+;fI|@*|$b**uz>Kf^QJ35Vkvf-XO(i3lRQmeuIv*({V@TPjek>q4;=M)) zPT+G9_|!-L7G@q-mL&dd$++#tUJowq!AAu!Y24?3c&^z}zx}skijwhl-~0D*5B)2v r|L+rwX5ax)yEtK|@Fbr4WAAsLBvUbWKB>XyRWKgNtH>4082SAdWACl= literal 0 HcmV?d00001 diff --git a/docs/test_8cpp_source.html b/docs/test_8cpp_source.html index c999c2e..a7c89d9 100644 --- a/docs/test_8cpp_source.html +++ b/docs/test_8cpp_source.html @@ -22,7 +22,7 @@
    quickpool -  1.3.0 +  1.4.0
    An easy-to-use, header-only work stealing thread pool in C++11
    @@ -75,340 +75,340 @@
    6 main()
    7 {
    8  using namespace quickpool;
    -
    9  mem::aligned_atomic<loop::State> test{};
    -
    10  std::cout << "lock free: " << test.is_lock_free() << std::endl;
    -
    11 
    -
    12  auto runs = 100;
    -
    13  for (auto run = 0; run < runs; run++) {
    -
    14  std::cout << "* [quickpool] unit tests: run " << run + 1 << "/" << runs
    -
    15  << "\t\r" << std::flush;
    -
    16 
    -
    17  // thread pool push
    -
    18  {
    -
    19  // std::cout << " * push: ";
    -
    20  std::vector<size_t> x(10000, 1);
    -
    21  for (size_t i = 0; i < x.size(); i++)
    -
    22  push([&](size_t i) -> void { x[i] = 2 * x[i]; }, i);
    -
    23  wait();
    -
    24 
    -
    25  size_t count_wrong = 0;
    -
    26  for (size_t i = 0; i < x.size(); i++) {
    -
    27  if (count_wrong += (x[i] != 2))
    -
    28  std::cout << x[i];
    -
    29  }
    -
    30  if (count_wrong > 0) {
    -
    31  throw std::runtime_error("static push gives wrong result");
    -
    32  }
    -
    33 
    -
    34  ThreadPool pool;
    -
    35  x = std::vector<size_t>(10000, 1);
    -
    36  for (size_t i = 0; i < x.size(); i++)
    -
    37  pool.push([&](size_t i) -> void { x[i] = 2 * x[i]; }, i);
    -
    38  pool.wait();
    -
    39 
    -
    40  count_wrong = 0;
    -
    41  for (size_t i = 0; i < x.size(); i++)
    -
    42  count_wrong += (x[i] != 2);
    -
    43  if (count_wrong > 0)
    -
    44  throw std::runtime_error("push gives wrong result");
    -
    45  // std::cout << "OK" << std::endl;
    -
    46  }
    -
    47 
    -
    48  // async()
    -
    49  {
    -
    50  // std::cout << " * async: ";
    -
    51  std::vector<size_t> x(10000, 1);
    -
    52  auto dummy = [&](size_t i) { return 2 * x[i]; };
    -
    53 
    -
    54  std::vector<std::future<size_t>> fut(x.size());
    -
    55  for (size_t i = 0; i < x.size(); i++)
    -
    56  fut[i] = async(dummy, i);
    -
    57  for (size_t i = 0; i < x.size(); i++)
    -
    58  x[i] = fut[i].get();
    -
    59  wait();
    -
    60 
    -
    61  size_t count_wrong = 0;
    -
    62  for (size_t i = 0; i < x.size(); i++)
    -
    63  count_wrong += (x[i] != 2);
    -
    64  if (count_wrong > 0)
    -
    65  throw std::runtime_error("static async gives wrong result");
    -
    66 
    -
    67  ThreadPool pool;
    -
    68  x = std::vector<size_t>(10000, 1);
    -
    69  std::vector<std::future<size_t>> fut2(x.size());
    -
    70  for (size_t i = 0; i < x.size(); i++)
    -
    71  fut2[i] = pool.async(dummy, i);
    -
    72  for (size_t i = 0; i < x.size(); i++)
    -
    73  x[i] = fut2[i].get();
    -
    74  pool.wait();
    -
    75 
    -
    76  count_wrong = 0;
    -
    77  for (size_t i = 0; i < x.size(); i++)
    -
    78  count_wrong += (x[i] != 2);
    -
    79  if (count_wrong > 0)
    -
    80  throw std::runtime_error("async gives wrong result");
    -
    81  // std::cout << "OK" << std::endl;
    -
    82  }
    -
    83 
    -
    84  // parallel_for()
    -
    85  {
    -
    86  // std::cout << " * parallel_for: ";
    -
    87  std::vector<size_t> x(10000, 1);
    -
    88  auto fun = [&](size_t i) { x[i] = 2 * x[i]; };
    -
    89  parallel_for(0, x.size(), fun);
    -
    90 
    -
    91  size_t count_wrong = 0;
    -
    92  for (size_t i = 0; i < x.size(); i++)
    -
    93  count_wrong += (x[i] != 2);
    -
    94  if (count_wrong > 0) {
    -
    95  for (auto xx : x)
    -
    96  std::cout << xx;
    -
    97  std::cout << std::endl;
    -
    98  throw std::runtime_error(
    -
    99  "static parallel_for gives wrong result");
    -
    100  }
    -
    101 
    -
    102  ThreadPool pool;
    -
    103  pool.parallel_for(0, x.size(), fun);
    -
    104 
    -
    105  count_wrong = 0;
    -
    106  for (size_t i = 0; i < x.size(); i++)
    -
    107  count_wrong += (x[i] != 4);
    -
    108  if (count_wrong > 0) {
    -
    109  for (auto xx : x)
    -
    110  std::cout << xx;
    -
    111  std::cout << std::endl;
    -
    112  throw std::runtime_error("parallel_for gives wrong result");
    -
    113  }
    -
    114  // std::cout << "OK" << std::endl;
    -
    115  }
    -
    116 
    -
    117  // nested parallel_for()
    -
    118  {
    -
    119  // std::cout << " * nested parallel_for: ";
    -
    120  std::vector<std::vector<double>> x(100);
    -
    121  for (auto& xx : x)
    -
    122  xx = std::vector<double>(100, 1.0);
    -
    123  parallel_for(0, x.size(), [&](int i) {
    -
    124  parallel_for(0, x[i].size(), [&x, i](int j) { x[i][j] *= 2; });
    -
    125  });
    -
    126 
    -
    127  size_t count_wrong = 0;
    -
    128  for (auto xx : x) {
    -
    129  for (auto xxx : xx)
    -
    130  count_wrong += xxx != 2;
    -
    131  }
    -
    132  if (count_wrong > 0) {
    -
    133  throw std::runtime_error(
    -
    134  "static nested parallel_for gives wrong result");
    -
    135  }
    -
    136 
    -
    137  ThreadPool pool;
    -
    138  pool.parallel_for(0, x.size(), [&](int i) {
    -
    139  pool.parallel_for(
    -
    140  0, x[i].size(), [&x, i](int j) { x[i][j] *= 2; });
    -
    141  });
    -
    142 
    -
    143  count_wrong = 0;
    -
    144  for (auto xx : x) {
    -
    145  for (auto xxx : xx)
    -
    146  count_wrong += xxx != 4;
    -
    147  }
    -
    148  if (count_wrong > 0) {
    -
    149  throw std::runtime_error(
    -
    150  "nested parallel_for gives wrong result");
    -
    151  }
    -
    152  // std::cout << "OK" << std::endl;
    -
    153  }
    -
    154 
    -
    155  // parallel_for_each()
    -
    156  {
    -
    157  // std::cout << " * parallel_for_each: ";
    -
    158  std::vector<size_t> x(10000, 1);
    -
    159  auto fun = [](size_t& xx) { xx = 2 * xx; };
    -
    160  parallel_for_each(x, fun);
    -
    161 
    -
    162  size_t count_wrong = 0;
    -
    163  for (size_t i = 0; i < x.size(); i++)
    -
    164  count_wrong += (x[i] != 2);
    -
    165  if (count_wrong > 0) {
    -
    166  for (auto xx : x)
    -
    167  std::cout << xx;
    -
    168  throw std::runtime_error(
    -
    169  "static parallel_for_each gives wrong result");
    -
    170  }
    -
    171 
    -
    172  ThreadPool pool;
    -
    173  pool.parallel_for_each(x, fun);
    -
    174 
    -
    175  count_wrong = 0;
    -
    176  for (size_t i = 0; i < x.size(); i++)
    -
    177  count_wrong += (x[i] != 4);
    -
    178  if (count_wrong > 0)
    -
    179  throw std::runtime_error(
    -
    180  "parallel_for_each gives wrong result");
    -
    181  // std::cout << "OK" << std::endl;
    -
    182  }
    -
    183 
    -
    184  // nested parallel_for_each()
    -
    185  {
    -
    186  // std::cout << " * nested parallel_for_each: ";
    -
    187  std::vector<std::vector<double>> x(100);
    -
    188  for (auto& xx : x)
    -
    189  xx = std::vector<double>(100, 1.0);
    -
    190  parallel_for_each(x, [](std::vector<double>& xx) {
    -
    191  parallel_for_each(xx, [](double& xxx) { xxx *= 2; });
    -
    192  });
    -
    193 
    -
    194  size_t count_wrong = 0;
    -
    195  for (auto xx : x) {
    -
    196  for (auto xxx : xx)
    -
    197  count_wrong += xxx != 2;
    -
    198  }
    -
    199  if (count_wrong > 0) {
    -
    200  throw std::runtime_error(
    -
    201  "static nested parallel_for_each gives wrong result");
    -
    202  }
    -
    203 
    -
    204  ThreadPool pool;
    -
    205  pool.parallel_for_each(x, [&](std::vector<double>& xx) {
    -
    206  pool.parallel_for_each(xx, [](double& xxx) { xxx *= 2; });
    -
    207  });
    -
    208 
    -
    209  count_wrong = 0;
    -
    210  for (auto xx : x) {
    -
    211  for (auto xxx : xx)
    -
    212  count_wrong += xxx != 4;
    -
    213  }
    -
    214  if (count_wrong > 0) {
    -
    215  throw std::runtime_error(
    -
    216  "nested parallel_for_each gives wrong result");
    -
    217  }
    -
    218  // std::cout << "OK" << std::endl;
    -
    219  }
    -
    220 
    -
    221  // single threaded
    -
    222  {
    -
    223  // std::cout << " * single threaded: ";
    -
    224  ThreadPool pool(0);
    -
    225  std::vector<size_t> x(1000, 1);
    -
    226  auto dummy = [&](size_t i) -> void { x[i] = 2 * x[i]; };
    -
    227 
    -
    228  for (size_t i = 0; i < x.size(); i++) {
    -
    229  pool.push(dummy, i);
    -
    230  }
    -
    231  pool.wait();
    -
    232 
    -
    233  size_t count_wrong = 0;
    -
    234  for (size_t i = 0; i < x.size(); i++)
    -
    235  count_wrong += (x[i] != 2);
    -
    236  if (count_wrong > 0)
    -
    237  throw std::runtime_error("single threaded gives wrong result");
    -
    238  // std::cout << "OK" << std::endl;
    -
    239  }
    -
    240 
    -
    241  // rethrows exceptions
    -
    242  {
    -
    243  // std::cout << " * exception handling: ";
    -
    244  ThreadPool pool;
    -
    245  // pool passes exceptions either via wait() or push()
    -
    246  std::exception_ptr eptr = nullptr;
    -
    247  try {
    -
    248  pool.push([] { throw std::runtime_error("test error"); });
    -
    249  std::this_thread::sleep_for(std::chrono::milliseconds(30));
    -
    250  for (size_t i = 0; i < 10; i++) {
    -
    251  pool.push([&] {});
    -
    252  }
    -
    253  } catch (...) {
    -
    254  eptr = std::current_exception();
    -
    255  }
    -
    256 
    -
    257  if (!eptr) {
    -
    258  throw std::runtime_error("exception not rethrown by push");
    -
    259  } else {
    -
    260  eptr = nullptr;
    -
    261  }
    -
    262 
    -
    263  // poool should be functional again
    -
    264  pool.push([] { throw std::runtime_error("test error"); });
    -
    265  try {
    -
    266  pool.wait();
    -
    267  } catch (...) {
    -
    268  eptr = std::current_exception();
    -
    269  }
    -
    270  if (!eptr) {
    -
    271  throw std::runtime_error("exception not rethrown by wait");
    -
    272  } else {
    -
    273  eptr = nullptr;
    -
    274  }
    -
    275  // std::cout << "OK" << std::endl;
    -
    276  }
    -
    277 
    -
    278  // can be resized
    -
    279  {
    -
    280  // std::cout << " * resizing: ";
    -
    281 
    -
    282  std::atomic_int dummy{ 0 };
    -
    283 
    -
    284  ThreadPool pool(2);
    -
    285  pool.set_active_threads(1);
    -
    286  for (int i = 0; i < 10000; i++)
    -
    287  pool.push([&] { dummy++; });
    -
    288  pool.wait();
    -
    289  if (dummy != 10000) {
    -
    290  throw std::runtime_error("downsizing doesn't work");
    -
    291  }
    -
    292 
    -
    293  pool.set_active_threads(2);
    -
    294  for (int i = 0; i < 10000; i++)
    -
    295  pool.push([&] { dummy++; });
    -
    296  pool.wait();
    +
    9  mem::aligned::atomic<loop::State> test{};
    +
    10  std::cout << "* [quickpool] lock free: "
    +
    11  << (test.is_lock_free() ? "yes\n" : "no\n");
    +
    12 
    +
    13  auto runs = 100;
    +
    14  for (auto run = 0; run < runs; run++) {
    +
    15  std::cout << "* [quickpool] unit tests: run " << run + 1 << "/" << runs
    +
    16  << "\t\r" << std::flush;
    +
    17 
    +
    18  // thread pool push
    +
    19  {
    +
    20  // std::cout << " * push: ";
    +
    21  std::vector<size_t> x(10000, 1);
    +
    22  for (size_t i = 0; i < x.size(); i++)
    +
    23  push([&](size_t i) -> void { x[i] = 2 * x[i]; }, i);
    +
    24  wait();
    +
    25 
    +
    26  size_t count_wrong = 0;
    +
    27  for (size_t i = 0; i < x.size(); i++) {
    +
    28  if (count_wrong += (x[i] != 2))
    +
    29  std::cout << x[i];
    +
    30  }
    +
    31  if (count_wrong > 0) {
    +
    32  throw std::runtime_error("static push gives wrong result");
    +
    33  }
    +
    34 
    +
    35  ThreadPool pool;
    +
    36  x = std::vector<size_t>(10000, 1);
    +
    37  for (size_t i = 0; i < x.size(); i++)
    +
    38  pool.push([&](size_t i) -> void { x[i] = 2 * x[i]; }, i);
    +
    39  pool.wait();
    +
    40 
    +
    41  count_wrong = 0;
    +
    42  for (size_t i = 0; i < x.size(); i++)
    +
    43  count_wrong += (x[i] != 2);
    +
    44  if (count_wrong > 0)
    +
    45  throw std::runtime_error("push gives wrong result");
    +
    46  // std::cout << "OK" << std::endl;
    +
    47  }
    +
    48 
    +
    49  // async()
    +
    50  {
    +
    51  // std::cout << " * async: ";
    +
    52  std::vector<size_t> x(10000, 1);
    +
    53  auto dummy = [&](size_t i) { return 2 * x[i]; };
    +
    54 
    +
    55  std::vector<std::future<size_t>> fut(x.size());
    +
    56  for (size_t i = 0; i < x.size(); i++)
    +
    57  fut[i] = async(dummy, i);
    +
    58  for (size_t i = 0; i < x.size(); i++)
    +
    59  x[i] = fut[i].get();
    +
    60  wait();
    +
    61 
    +
    62  size_t count_wrong = 0;
    +
    63  for (size_t i = 0; i < x.size(); i++)
    +
    64  count_wrong += (x[i] != 2);
    +
    65  if (count_wrong > 0)
    +
    66  throw std::runtime_error("static async gives wrong result");
    +
    67 
    +
    68  ThreadPool pool;
    +
    69  x = std::vector<size_t>(10000, 1);
    +
    70  std::vector<std::future<size_t>> fut2(x.size());
    +
    71  for (size_t i = 0; i < x.size(); i++)
    +
    72  fut2[i] = pool.async(dummy, i);
    +
    73  for (size_t i = 0; i < x.size(); i++)
    +
    74  x[i] = fut2[i].get();
    +
    75  pool.wait();
    +
    76 
    +
    77  count_wrong = 0;
    +
    78  for (size_t i = 0; i < x.size(); i++)
    +
    79  count_wrong += (x[i] != 2);
    +
    80  if (count_wrong > 0)
    +
    81  throw std::runtime_error("async gives wrong result");
    +
    82  // std::cout << "OK" << std::endl;
    +
    83  }
    +
    84 
    +
    85  // parallel_for()
    +
    86  {
    +
    87  // std::cout << " * parallel_for: ";
    +
    88  std::vector<size_t> x(10000, 1);
    +
    89  auto fun = [&](size_t i) { x[i] = 2 * x[i]; };
    +
    90  parallel_for(0, x.size(), fun);
    +
    91 
    +
    92  size_t count_wrong = 0;
    +
    93  for (size_t i = 0; i < x.size(); i++)
    +
    94  count_wrong += (x[i] != 2);
    +
    95  if (count_wrong > 0) {
    +
    96  for (auto xx : x)
    +
    97  std::cout << xx;
    +
    98  std::cout << std::endl;
    +
    99  throw std::runtime_error(
    +
    100  "static parallel_for gives wrong result");
    +
    101  }
    +
    102 
    +
    103  ThreadPool pool;
    +
    104  pool.parallel_for(0, x.size(), fun);
    +
    105 
    +
    106  count_wrong = 0;
    +
    107  for (size_t i = 0; i < x.size(); i++)
    +
    108  count_wrong += (x[i] != 4);
    +
    109  if (count_wrong > 0) {
    +
    110  for (auto xx : x)
    +
    111  std::cout << xx;
    +
    112  std::cout << std::endl;
    +
    113  throw std::runtime_error("parallel_for gives wrong result");
    +
    114  }
    +
    115  // std::cout << "OK" << std::endl;
    +
    116  }
    +
    117 
    +
    118  // nested parallel_for()
    +
    119  {
    +
    120  // std::cout << " * nested parallel_for: ";
    +
    121  std::vector<std::vector<double>> x(100);
    +
    122  for (auto& xx : x)
    +
    123  xx = std::vector<double>(100, 1.0);
    +
    124  parallel_for(0, x.size(), [&](int i) {
    +
    125  parallel_for(0, x[i].size(), [&x, i](int j) { x[i][j] *= 2; });
    +
    126  });
    +
    127 
    +
    128  size_t count_wrong = 0;
    +
    129  for (auto xx : x) {
    +
    130  for (auto xxx : xx)
    +
    131  count_wrong += xxx != 2;
    +
    132  }
    +
    133  if (count_wrong > 0) {
    +
    134  throw std::runtime_error(
    +
    135  "static nested parallel_for gives wrong result");
    +
    136  }
    +
    137 
    +
    138  ThreadPool pool;
    +
    139  pool.parallel_for(0, x.size(), [&](int i) {
    +
    140  pool.parallel_for(
    +
    141  0, x[i].size(), [&x, i](int j) { x[i][j] *= 2; });
    +
    142  });
    +
    143 
    +
    144  count_wrong = 0;
    +
    145  for (auto xx : x) {
    +
    146  for (auto xxx : xx)
    +
    147  count_wrong += xxx != 4;
    +
    148  }
    +
    149  if (count_wrong > 0) {
    +
    150  throw std::runtime_error(
    +
    151  "nested parallel_for gives wrong result");
    +
    152  }
    +
    153  // std::cout << "OK" << std::endl;
    +
    154  }
    +
    155 
    +
    156  // parallel_for_each()
    +
    157  {
    +
    158  // std::cout << " * parallel_for_each: ";
    +
    159  std::vector<size_t> x(10000, 1);
    +
    160  auto fun = [](size_t& xx) { xx = 2 * xx; };
    +
    161  parallel_for_each(x, fun);
    +
    162 
    +
    163  size_t count_wrong = 0;
    +
    164  for (size_t i = 0; i < x.size(); i++)
    +
    165  count_wrong += (x[i] != 2);
    +
    166  if (count_wrong > 0) {
    +
    167  for (auto xx : x)
    +
    168  std::cout << xx;
    +
    169  throw std::runtime_error(
    +
    170  "static parallel_for_each gives wrong result");
    +
    171  }
    +
    172 
    +
    173  ThreadPool pool;
    +
    174  pool.parallel_for_each(x, fun);
    +
    175 
    +
    176  count_wrong = 0;
    +
    177  for (size_t i = 0; i < x.size(); i++)
    +
    178  count_wrong += (x[i] != 4);
    +
    179  if (count_wrong > 0)
    +
    180  throw std::runtime_error(
    +
    181  "parallel_for_each gives wrong result");
    +
    182  // std::cout << "OK" << std::endl;
    +
    183  }
    +
    184 
    +
    185  // nested parallel_for_each()
    +
    186  {
    +
    187  // std::cout << " * nested parallel_for_each: ";
    +
    188  std::vector<std::vector<double>> x(100);
    +
    189  for (auto& xx : x)
    +
    190  xx = std::vector<double>(100, 1.0);
    +
    191  parallel_for_each(x, [](std::vector<double>& xx) {
    +
    192  parallel_for_each(xx, [](double& xxx) { xxx *= 2; });
    +
    193  });
    +
    194 
    +
    195  size_t count_wrong = 0;
    +
    196  for (auto xx : x) {
    +
    197  for (auto xxx : xx)
    +
    198  count_wrong += xxx != 2;
    +
    199  }
    +
    200  if (count_wrong > 0) {
    +
    201  throw std::runtime_error(
    +
    202  "static nested parallel_for_each gives wrong result");
    +
    203  }
    +
    204 
    +
    205  ThreadPool pool;
    +
    206  pool.parallel_for_each(x, [&](std::vector<double>& xx) {
    +
    207  pool.parallel_for_each(xx, [](double& xxx) { xxx *= 2; });
    +
    208  });
    +
    209 
    +
    210  count_wrong = 0;
    +
    211  for (auto xx : x) {
    +
    212  for (auto xxx : xx)
    +
    213  count_wrong += xxx != 4;
    +
    214  }
    +
    215  if (count_wrong > 0) {
    +
    216  throw std::runtime_error(
    +
    217  "nested parallel_for_each gives wrong result");
    +
    218  }
    +
    219  // std::cout << "OK" << std::endl;
    +
    220  }
    +
    221 
    +
    222  // single threaded
    +
    223  {
    +
    224  // std::cout << " * single threaded: ";
    +
    225  ThreadPool pool(0);
    +
    226  std::vector<size_t> x(1000, 1);
    +
    227  auto dummy = [&](size_t i) -> void { x[i] = 2 * x[i]; };
    +
    228 
    +
    229  for (size_t i = 0; i < x.size(); i++) {
    +
    230  pool.push(dummy, i);
    +
    231  }
    +
    232  pool.wait();
    +
    233 
    +
    234  size_t count_wrong = 0;
    +
    235  for (size_t i = 0; i < x.size(); i++)
    +
    236  count_wrong += (x[i] != 2);
    +
    237  if (count_wrong > 0)
    +
    238  throw std::runtime_error("single threaded gives wrong result");
    +
    239  // std::cout << "OK" << std::endl;
    +
    240  }
    +
    241 
    +
    242  // rethrows exceptions
    +
    243  {
    +
    244  // std::cout << " * exception handling: ";
    +
    245  ThreadPool pool;
    +
    246  // pool passes exceptions either via wait() or push()
    +
    247  std::exception_ptr eptr = nullptr;
    +
    248  try {
    +
    249  pool.push([] { throw std::runtime_error("test error"); });
    +
    250  std::this_thread::sleep_for(std::chrono::milliseconds(30));
    +
    251  for (size_t i = 0; i < 10; i++) {
    +
    252  pool.push([&] {});
    +
    253  }
    +
    254  } catch (...) {
    +
    255  eptr = std::current_exception();
    +
    256  }
    +
    257 
    +
    258  if (!eptr) {
    +
    259  throw std::runtime_error("exception not rethrown by push");
    +
    260  } else {
    +
    261  eptr = nullptr;
    +
    262  }
    +
    263 
    +
    264  // poool should be functional again
    +
    265  pool.push([] { throw std::runtime_error("test error"); });
    +
    266  try {
    +
    267  pool.wait();
    +
    268  } catch (...) {
    +
    269  eptr = std::current_exception();
    +
    270  }
    +
    271  if (!eptr) {
    +
    272  throw std::runtime_error("exception not rethrown by wait");
    +
    273  } else {
    +
    274  eptr = nullptr;
    +
    275  }
    +
    276  // std::cout << "OK" << std::endl;
    +
    277  }
    +
    278 
    +
    279  // can be resized
    +
    280  {
    +
    281  // std::cout << " * resizing: ";
    +
    282 
    +
    283  std::atomic_int dummy{ 0 };
    +
    284 
    +
    285  ThreadPool pool(2);
    +
    286  pool.set_active_threads(1);
    +
    287  for (int i = 0; i < 100; i++)
    +
    288  pool.push([&] { dummy++; });
    +
    289  pool.wait();
    +
    290  if (dummy != 100) {
    +
    291  throw std::runtime_error("downsizing doesn't work");
    +
    292  }
    +
    293 
    +
    294  pool.set_active_threads(2);
    +
    295  for (int i = 0; i < 100; i++)
    +
    296  pool.push([&] { dummy++; });
    297  pool.wait();
    -
    298  if (dummy != 20000) {
    -
    299  throw std::runtime_error("restore size doesn't work");
    -
    300  }
    -
    301 
    -
    302  pool.set_active_threads(3);
    -
    303  for (int i = 0; i < 10000; i++)
    -
    304  pool.push([&] { dummy++; });
    -
    305  pool.wait();
    +
    298  pool.wait();
    +
    299  if (dummy != 200) {
    +
    300  throw std::runtime_error("restore size doesn't work");
    +
    301  }
    +
    302 
    +
    303  pool.set_active_threads(3);
    +
    304  for (int i = 0; i < 100; i++)
    +
    305  pool.push([&] { dummy++; });
    306  pool.wait();
    -
    307  if (dummy != 30000) {
    -
    308  throw std::runtime_error("upsizing doesn't work");
    -
    309  }
    -
    310 
    -
    311  pool.set_active_threads(std::thread::hardware_concurrency() + 1);
    -
    312  for (int i = 0; i < 10000; i++)
    -
    313  pool.push([&] { dummy++; });
    -
    314  pool.wait();
    +
    307  pool.wait();
    +
    308  if (dummy != 300) {
    +
    309  throw std::runtime_error("upsizing doesn't work");
    +
    310  }
    +
    311 
    +
    312  pool.set_active_threads(std::thread::hardware_concurrency() + 1);
    +
    313  for (int i = 0; i < 100; i++)
    +
    314  pool.push([&] { dummy++; });
    315  pool.wait();
    -
    316  if (dummy != 40000) {
    -
    317  throw std::runtime_error("oversizing doesn't work");
    -
    318  }
    -
    319 
    +
    316  pool.wait();
    +
    317  if (dummy != 400) {
    +
    318  throw std::runtime_error("oversizing doesn't work");
    +
    319  }
    320 
    321  // std::cout << "OK" << std::endl;
    322  }
    323  }
    324 
    -
    325  std::cout << "- unit tests: OK " << std::endl;
    +
    325  std::cout << "* [quickpool] unit tests: OK " << std::endl;
    326 
    327  return 0;
    328 }
    -
    quickpool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction &&f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:954
    -
    quickpool
    quickpool namespace
    Definition: quickpool.hpp:55
    -
    quickpool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction &&f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:971
    -
    quickpool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously the global thread pool.
    Definition: quickpool.hpp:905
    -
    quickpool::ThreadPool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:781
    -
    quickpool::ThreadPool::wait
    void wait(size_t millis=0)
    waits for all jobs currently running on the thread pool. Has no effect when called from threads other...
    Definition: quickpool.hpp:814
    -
    quickpool::ThreadPool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:803
    -
    quickpool::wait
    void wait()
    waits for all jobs currently running on the global thread pool. Has no effect when not called from ma...
    Definition: quickpool.hpp:914
    -
    quickpool::ThreadPool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously on the global thread pool.
    Definition: quickpool.hpp:760
    -
    quickpool::ThreadPool::set_active_threads
    void set_active_threads(size_t threads)
    sets the number of active worker threads in the thread pool.
    Definition: quickpool.hpp:718
    -
    quickpool::ThreadPool
    A work stealing thread pool.
    Definition: quickpool.hpp:678
    -
    quickpool::ThreadPool::push
    void push(Function &&f, Args &&... args)
    pushes a job to the thread pool.
    Definition: quickpool.hpp:746
    -
    quickpool::push
    void push(Function &&f, Args &&... args)
    Free-standing functions (main API)
    Definition: quickpool.hpp:892
    +
    quickpool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction &&f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:1041
    +
    quickpool
    quickpool namespace
    Definition: quickpool.hpp:57
    +
    quickpool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction &&f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:1058
    +
    quickpool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously the global thread pool.
    Definition: quickpool.hpp:992
    +
    quickpool::ThreadPool::parallel_for
    void parallel_for(int begin, int end, UnaryFunction f)
    computes an index-based parallel for loop.
    Definition: quickpool.hpp:859
    +
    quickpool::ThreadPool::wait
    void wait(size_t millis=0)
    waits for all jobs currently running on the thread pool. Has no effect when called from threads other...
    Definition: quickpool.hpp:892
    +
    quickpool::ThreadPool::parallel_for_each
    void parallel_for_each(Items &items, UnaryFunction f)
    computes a iterator-based parallel for loop.
    Definition: quickpool.hpp:881
    +
    quickpool::wait
    void wait()
    waits for all jobs currently running on the global thread pool. Has no effect when not called from ma...
    Definition: quickpool.hpp:1001
    +
    quickpool::ThreadPool::async
    auto async(Function &&f, Args &&... args) -> std::future< decltype(f(args...))>
    executes a job asynchronously on the global thread pool.
    Definition: quickpool.hpp:838
    +
    quickpool::ThreadPool::set_active_threads
    void set_active_threads(size_t threads)
    sets the number of active worker threads in the thread pool.
    Definition: quickpool.hpp:796
    +
    quickpool::ThreadPool
    A work stealing thread pool.
    Definition: quickpool.hpp:756
    +
    quickpool::ThreadPool::push
    void push(Function &&f, Args &&... args)
    pushes a job to the thread pool.
    Definition: quickpool.hpp:824
    +
    quickpool::push
    void push(Function &&f, Args &&... args)
    Free-standing functions (main API)
    Definition: quickpool.hpp:979
    Generated by   diff --git a/quickpool.hpp b/quickpool.hpp index f1ec3c2..1273da1 100644 --- a/quickpool.hpp +++ b/quickpool.hpp @@ -41,6 +41,7 @@ // 1. Memory related utilities. // - Memory order aliases // - Class for padding bytes +// - Memory aligned allocation utilities // - Class for cache aligned atomics // - Class for load/assign atomics with relaxed order // 2. Loop related utilities. @@ -104,18 +105,103 @@ struct padding } // end namespace padding_impl +namespace aligned { + +// The alloc/dealloc mechanism is pretty much +// https://www.boost.org/doc/libs/1_76_0/boost/align/detail/aligned_alloc.hpp + +inline void* +alloc(size_t alignment, size_t size) noexcept +{ + // Make sure alignment is at least that of void*. + alignment = (alignment >= alignof(void*)) ? alignment : alignof(void*); + + // Allocate enough space required for object and a void*. + size_t space = size + alignment + sizeof(void*); + void* p = std::malloc(space); + if (p == nullptr) { + return nullptr; + } + + // Shift pointer to leave space for void*. + void* p_algn = static_cast(p) + sizeof(void*); + space -= sizeof(void*); + + // Shift pointer further to ensure proper alignment. + (void)std::align(alignment, size, p_algn, space); + + // Store unaligned pointer with offset sizeof(void*) before aligned + // location. Later we'll know where to look for the pointer telling + // us where to free what we malloc()'ed above. + *(static_cast(p_algn) - 1) = p; + + return p_algn; +} + +inline void +free(void* ptr) noexcept +{ + if (ptr) { + std::free(*(static_cast(ptr) - 1)); + } +} + +//! short version of +//! https://www.boost.org/doc/libs/1_65_0/boost/align/aligned_allocator.hpp +template +class allocator : public std::allocator +{ + private: + static constexpr size_t min_align = + (Alignment >= alignof(void*)) ? Alignment : alignof(void*); + + public: + template + struct rebind + { + typedef allocator other; + }; + + T* allocate(size_t size, const void* = 0) + { + if (size == 0) { + return 0; + } + void* p = mem::aligned::alloc(min_align, sizeof(T) * size); + if (!p) { + throw std::bad_alloc(); + } + return static_cast(p); + } + + void deallocate(T* ptr, size_t) { mem::aligned::free(ptr); } + + template + void construct(U* ptr, Args&&... args) + { + ::new ((void*)ptr) U(std::forward(args)...); + } + + template + void destroy(U* ptr) + { + (void)ptr; + ptr->~U(); + } +}; + //! Memory-aligned atomic `std::atomic`. Behaves like `std::atomic`, but //! overloads operators `new` and `delete` to align its memory location. Padding //! bytes are added if necessary. template -struct alignas(Align) aligned_atomic +struct alignas(Align) atomic : public std::atomic , private padding_impl::padding { public: - aligned_atomic() noexcept = default; + atomic() noexcept = default; - aligned_atomic(T desired) noexcept + atomic(T desired) noexcept : std::atomic(desired) {} @@ -123,51 +209,20 @@ struct alignas(Align) aligned_atomic T operator=(T x) noexcept { return std::atomic::operator=(x); } T operator=(T x) volatile noexcept { return std::atomic::operator=(x); } - // The alloc/dealloc mechanism is pretty much - // https://www.boost.org/doc/libs/1_76_0/boost/align/detail/aligned_alloc.hpp static void* operator new(size_t count) noexcept { - // Make sure alignment is at least that of void*. - constexpr size_t alignment = - (Align >= alignof(void*)) ? Align : alignof(void*); - - // Allocate enough space required for object and a void*. - size_t space = count + alignment + sizeof(void*); - void* p = std::malloc(space); - if (p == nullptr) { - return nullptr; - } - - // Shift pointer to leave space for void*. - void* p_algn = static_cast(p) + sizeof(void*); - space -= sizeof(void*); - - // Shift pointer further to ensure proper alignment. - (void)std::align(alignment, count, p_algn, space); - - // Store unaligned pointer with offset sizeof(void*) before aligned - // location. Later we'll know where to look for the pointer telling - // us where to free what we malloc()'ed above. - *(static_cast(p_algn) - 1) = p; - - return p_algn; + return mem::aligned::alloc(Align, count); } - static void operator delete(void* ptr) - { - if (ptr) { - // Read pointer to start of malloc()'ed block and free there. - std::free(*(static_cast(ptr) - 1)); - } - } + static void operator delete(void* ptr) { mem::aligned::free(ptr); } }; //! Fast and simple load/assign atomic with no memory ordering guarantees. template -struct relaxed_atomic : public aligned_atomic +struct relaxed_atomic : public mem::aligned::atomic { explicit relaxed_atomic(T value) - : mem::aligned_atomic(value) + : mem::aligned::atomic(value) {} operator T() const noexcept { return this->load(mem::relaxed); } @@ -179,6 +234,12 @@ struct relaxed_atomic : public aligned_atomic } }; +//! vector class for aligned types. +template +using vector = std::vector>; + +} // end namespace aligned + } // end namespace mem // 2. -------------------------------------------------------------------------- @@ -219,20 +280,21 @@ struct Worker size_t tasks_left() const { - State s = state; + State s = state.load(); return s.end - s.pos; } bool done() const { return (tasks_left() == 0); } //! @param others pointer to the vector of all workers. - void run(std::shared_ptr> others) + void run(std::shared_ptr> others) { State s, s_old; // temporary state variables do { - s = state; + s = state.load(); if (s.pos < s.end) { - // Protect slot by trying to advance position before doing work. + // Protect slot by trying to advance position before doing + // work. s_old = s; s.pos++; @@ -247,24 +309,25 @@ struct Worker } if (s.pos == s.end) { // Reached end of own range, steal range from others. Range - // remains empty if all work is done, so we can leave the loop. + // remains empty if all work is done, so we can leave the + // loop. this->steal_range(*others); } } while (!this->done()); } //! @param workers vector of all workers. - void steal_range(std::vector& workers) + void steal_range(mem::aligned::vector& workers) { do { Worker& other = find_victim(workers); - State s = other.state; + State s = other.state.load(); if (s.pos >= s.end) { continue; // other range is empty by now } - // Remove second half of the range. Check atomically if the state is - // unaltered and, if so, replace with reduced range. + // Remove second half of the range. Check atomically if the + // state is unaltered and, if so, replace with reduced range. auto s_old = s; s.end -= (s.end - s.pos + 1) / 2; if (other.state.compare_exchange_weak(s_old, s)) { @@ -276,7 +339,7 @@ struct Worker } //! @param workers vector of all workers. - bool all_done(const std::vector& workers) + bool all_done(const mem::aligned::vector& workers) { for (const auto& worker : workers) { if (!worker.done()) @@ -285,10 +348,10 @@ struct Worker return true; } - //! targets the worker with the largest remaining range to minimize number - //! of steal events. + //! targets the worker with the largest remaining range to minimize + //! number of steal events. //! @param others vector of all workers. - Worker& find_victim(std::vector& workers) + Worker& find_victim(mem::aligned::vector& workers) { std::vector tasks_left; tasks_left.reserve(workers.size()); @@ -300,27 +363,28 @@ struct Worker return workers[idx]; } - mem::relaxed_atomic state; //!< worker state `{pos, end}` - Function f; //< function applied to the loop index + mem::aligned::relaxed_atomic state; //!< worker state `{pos, end}` + Function f; //< function applied to the loop index }; //! creates loop workers. They must be passed to each worker using a shared //! pointer, so that they persist if an inner `parallel_for()` in a nested //! loop exits. template -std::shared_ptr>> +std::shared_ptr>> create_workers(const Function& f, int begin, int end, size_t num_workers) { auto num_tasks = std::max(end - begin, static_cast(0)); num_workers = std::max(num_workers, static_cast(1)); - auto workers = new std::vector>; + auto workers = new mem::aligned::vector>; workers->reserve(num_workers); for (size_t i = 0; i < num_workers; i++) { workers->emplace_back(begin + num_tasks * i / num_workers, begin + num_tasks * (i + 1) / num_workers, f); } - return std::shared_ptr>>(std::move(workers)); + return std::shared_ptr>>( + std::move(workers)); } } // end namespace loop @@ -466,8 +530,8 @@ class TaskQueue private: //! queue indices - mem::aligned_atomic top_{ 0 }; - mem::aligned_atomic bottom_{ 0 }; + mem::aligned::atomic top_{ 0 }; + mem::aligned::atomic bottom_{ 0 }; //! ring buffer holding task pointers std::atomic*> buffer_{ nullptr }; @@ -486,9 +550,9 @@ class TaskManager { public: explicit TaskManager(size_t num_queues) - : queues_{ std::vector(num_queues) } - , num_queues_{ num_queues } - , owner_id_{ std::this_thread::get_id() } + : queues_(num_queues) + , num_queues_(num_queues) + , owner_id_(std::this_thread::get_id()) {} TaskManager& operator=(TaskManager&& other) @@ -506,7 +570,7 @@ class TaskManager { num_queues_ = std::max(num_queues, static_cast(1)); if (num_queues > queues_.size()) { - queues_ = std::vector(num_queues); + queues_ = mem::aligned::vector(num_queues); // thread pool must have stopped the manager, reset num_waiting_ = 0; todo_ = 0; @@ -588,7 +652,8 @@ class TaskManager auto n = todo_.fetch_sub(1, mem::release) - 1; if (n == 0) { - // all jobs are done; lock before signal to prevent spurious failure + // all jobs are done; lock before signal to prevent spurious + // failure { std::lock_guard lk{ mtx_ }; } @@ -626,7 +691,8 @@ class TaskManager // Exceptions are only thrown from the owner thread, not in workers. if (called_from_owner_thread() && has_errored()) { { - // Wait for all threads to idle so we can clean up after them. + // Wait for all threads to idle so we can clean up after + // them. std::unique_lock lk(mtx_); cv_.wait(lk, [this] { return num_waiting_ == queues_.size(); }); } @@ -660,13 +726,13 @@ class TaskManager private: //! worker queues - std::vector queues_; + mem::aligned::vector queues_; size_t num_queues_; //! task management - mem::relaxed_atomic num_waiting_{ 0 }; - mem::relaxed_atomic push_idx_{ 0 }; - mem::aligned_atomic todo_{ 0 }; + mem::aligned::relaxed_atomic num_waiting_{ 0 }; + mem::aligned::relaxed_atomic push_idx_{ 0 }; + mem::aligned::atomic todo_{ 0 }; //! synchronization variables const std::thread::id owner_id_; @@ -676,7 +742,7 @@ class TaskManager errored, stopped }; - mem::aligned_atomic status_{ Status::running }; + mem::aligned::atomic status_{ Status::running }; std::mutex mtx_; std::condition_variable cv_; std::exception_ptr err_ptr_{ nullptr }; @@ -828,6 +894,15 @@ class ThreadPool //! @brief checks whether all jobs are done. bool done() const { return task_manager_.done(); } + //! @brief allocator respecting memory alignment. + static void* operator new(size_t count) + { + return mem::aligned::alloc(alignof(ThreadPool), count); + } + + //! @brief deallocator respecting memory alignment. + static void operator delete(void* ptr) { mem::aligned::free(ptr); } + private: //! joins all worker threads. void join_threads() diff --git a/test.cpp b/test.cpp index 8ea4460..28236c8 100644 --- a/test.cpp +++ b/test.cpp @@ -6,8 +6,9 @@ int main() { using namespace quickpool; - mem::aligned_atomic test{}; - std::cout << "* [quickpool] lock free: " << (test.is_lock_free() ? "yes\n" : "no\n"); + mem::aligned::atomic test{}; + std::cout << "* [quickpool] lock free: " + << (test.is_lock_free() ? "yes\n" : "no\n"); auto runs = 100; for (auto run = 0; run < runs; run++) { @@ -317,7 +318,6 @@ main() throw std::runtime_error("oversizing doesn't work"); } - // std::cout << "OK" << std::endl; } }