feature: switch threader_for to int64 indices

.ci/scripts/abi_check.sh

@@ -34,6 +34,7 @@ fi
 for i in "${solibs[@]}"
 do
     name=$(basename $i)
+    if [[ "$name" == *"libonedal_thread"* ]]; then continue; fi
     echo "======== ${name} ========"
     abidiff --suppr .github/.abignore $i $release_dir/$name
     retVal=$?

cpp/daal/src/externals/core_threading_win_dll.cpp

@@ -97,16 +97,29 @@ FARPROC load_daal_thr_func(const char * ordinal)
 typedef void * (*_threaded_malloc_t)(const size_t, const size_t);
 typedef void (*_threaded_free_t)(void *);
 
-typedef void (*_daal_threader_for_t)(int, int, const void *, daal::functype);
-typedef void (*_daal_threader_for_int64_t)(int64_t, const void *, daal::functype_int64);
-typedef void (*_daal_threader_for_int32ptr_t)(const int *, const int *, const void *, daal::functype_int32ptr);
-typedef void (*_daal_threader_for_simple_t)(int, int, const void *, daal::functype);
-typedef void (*_daal_static_threader_for_t)(size_t, const void *, daal::functype_static);
-typedef void (*_daal_threader_for_blocked_t)(int, int, const void *, daal::functype2);
-typedef void (*_daal_threader_for_blocked_size_t)(size_t, size_t, const void *, daal::functype_blocked_size);
 typedef int (*_daal_threader_get_max_threads_t)(void);
 typedef int (*_daal_threader_get_current_thread_index_t)(void);
-typedef void (*_daal_threader_for_break_t)(int, int, const void *, daal::functype_break);
+
+typedef void (*_daal_static_threader_for_t)(int64_t, const void *, daal::functype_static);
+typedef void (*_daal_static_threader_for_size_t)(size_t, const void *, daal::functype_static_size_t);
+
+typedef void (*_daal_threader_for_t)(int64_t, int64_t, const void *, daal::functype);
+typedef void (*_daal_threader_for_int32_t)(int, int, const void *, daal::functype_int32);
+
+typedef void (*_daal_threader_for_simple_t)(int64_t, int64_t, const void *, daal::functype);
+typedef void (*_daal_threader_for_simple_int32_t)(int, int, const void *, daal::functype_int32);
+
+typedef void (*_daal_threader_for_ptr_t)(const int64_t *, const int64_t *, const void *, daal::functype_int64ptr);
+typedef void (*_daal_threader_for_int32ptr_t)(const int64_t *, const int64_t *, const void *, daal::functype_int32ptr);
+
+typedef void (*_daal_threader_for_blocked_t)(int64_t, int64_t, const void *, daal::functype2);
+typedef void (*_daal_threader_for_blocked_int32_t)(int, int, const void *, daal::functype2_int32);
+
+typedef void (*_daal_threader_for_optional_t)(int64_t, int64_t, const void *, daal::functype);
+typedef void (*_daal_threader_for_optional_int32_t)(int, int, const void *, daal::functype_int32);
+
+typedef void (*_daal_threader_for_break_t)(int64_t, int64_t, const void *, daal::functype_break);
+typedef void (*_daal_threader_for_break_int32_t)(int, int, const void *, daal::functype_break_int32);
 
 typedef int64_t (*_daal_parallel_reduce_int32_int64_t)(int32_t, int64_t, const void *, daal::loop_functype_int32_int64, const void *,
                                                        daal::reduction_functype_int64);
@@ -179,37 +192,44 @@ DAAL_EXPORT void _threaded_scalable_free(void * ptr)
     _threaded_free_ptr(ptr);
 }
 
-DAAL_EXPORT void _daal_threader_for(int n, int threads_request, const void * a, daal::functype func)
+DAAL_EXPORT void _daal_threader_for(int64_t n, int64_t grain_size, const void * a, daal::functype func)
 {
     load_daal_thr_dll();
     static _daal_threader_for_t _daal_threader_for_ptr = (_daal_threader_for_t)load_daal_thr_func("_daal_threader_for");
-    _daal_threader_for_ptr(n, threads_request, a, func);
+    _daal_threader_for_ptr(n, grain_size, a, func);
 }
 
-DAAL_EXPORT void _daal_threader_for_simple(int n, int threads_request, const void * a, daal::functype func)
+DAAL_EXPORT void _daal_threader_for_int32(int n, int grain_size, const void * a, daal::functype func)
 {
     load_daal_thr_dll();
-    static _daal_threader_for_simple_t _daal_threader_for_simple_ptr = (_daal_threader_for_simple_t)load_daal_thr_func("_daal_threader_for_simple");
-    _daal_threader_for_simple_ptr(n, threads_request, a, func);
+    static _daal_threader_for_t _daal_threader_for_ptr = (_daal_threader_for_t)load_daal_thr_func("_daal_threader_for_int32");
+    _daal_threader_for_ptr(n, grain_size, a, func);
 }
 
-DAAL_EXPORT void _daal_threader_for_int32ptr(const int * begin, const int * end, const void * a, daal::functype_int32ptr func)
+DAAL_EXPORT void _daal_threader_for_simple(int64_t n, int64_t grain_size, const void * a, daal::functype func)
 {
     load_daal_thr_dll();
+    static _daal_threader_for_simple_t _daal_threader_for_simple_ptr = (_daal_threader_for_simple_t)load_daal_thr_func("_daal_threader_for_simple");
+    _daal_threader_for_simple_ptr(n, grain_size, a, func);
+}
 
-    static _daal_threader_for_int32ptr_t _daal_threader_for_int32ptr_ptr =
-        (_daal_threader_for_int32ptr_t)load_daal_thr_func("_daal_threader_for_int32ptr");
-    _daal_threader_for_int32ptr_ptr(begin, end, a, func);
+DAAL_EXPORT void _daal_threader_for_simple_int32(int n, int grain_size, const void * a, daal::functype func)
+{
+    load_daal_thr_dll();
+    static _daal_threader_for_simple_t _daal_threader_for_simple_ptr = (_daal_threader_for_simple_t)load_daal_thr_func("_daal_threader_for_simple");
+    _daal_threader_for_simple_ptr(n, grain_size, a, func);
 }
 
-DAAL_EXPORT void _daal_threader_for_int64(int64_t n, const void * a, daal::functype_int64 func)
+DAAL_EXPORT void _daal_threader_for_int64ptr(const int64_t * begin, const int64_t * end, const void * a, daal::functype_int64ptr func)
 {
     load_daal_thr_dll();
-    static _daal_threader_for_int64_t _daal_threader_for_int64_ptr = (_daal_threader_for_int64_t)load_daal_thr_func("_daal_threader_for_int64");
-    _daal_threader_for_int64_ptr(n, a, func);
+
+    static _daal_threader_for_int64ptr_t _daal_threader_for_int64ptr_ptr =
+        (_daal_threader_for_int64ptr_t)load_daal_thr_func("_daal_threader_for_int64ptr");
+    _daal_threader_for_int64ptr_ptr(begin, end, a, func);
 }
 
-DAAL_EXPORT void _daal_static_threader_for(size_t n, const void * a, daal::functype_static func)
+DAAL_EXPORT void _daal_static_threader_for(int64_t n, const void * a, daal::functype_static func)
 {
     load_daal_thr_dll();
     static _daal_static_threader_for_t _daal_static_threader_for_ptr = (_daal_static_threader_for_t)load_daal_thr_func("_daal_static_threader_for");
@@ -255,27 +275,20 @@ DAAL_EXPORT void _daal_parallel_sort_pair_fp64_uint64(daal::IdxValType<double> *
     _daal_parallel_sort_pair_fp64_uint64_ptr(begin_ptr, end_ptr);
 }
 
-DAAL_EXPORT void _daal_threader_for_blocked(int n, int threads_request, const void * a, daal::functype2 func)
+DAAL_EXPORT void _daal_threader_for_blocked(int64_t n, int64_t grain_size, const void * a, daal::functype_blocked func)
 {
     load_daal_thr_dll();
     static _daal_threader_for_blocked_t _daal_threader_for_blocked_ptr =
         (_daal_threader_for_blocked_t)load_daal_thr_func("_daal_threader_for_blocked");
-    _daal_threader_for_blocked_ptr(n, threads_request, a, func);
-}
-
-DAAL_EXPORT void _daal_threader_for_blocked_size(size_t n, size_t block, const void * a, daal::functype_blocked_size func)
-{
-    load_daal_thr_dll();
-    static _daal_threader_for_blocked_size_t _daal_threader_for_blocked_size_ptr =
-        (_daal_threader_for_blocked_size_t)load_daal_thr_func("_daal_threader_for_blocked_size");
-    _daal_threader_for_blocked_size_ptr(n, block, a, func);
+    _daal_threader_for_blocked_ptr(n, grain_size, a, func);
 }
 
-DAAL_EXPORT void _daal_threader_for_optional(int n, int threads_request, const void * a, daal::functype func)
+DAAL_EXPORT void _daal_threader_for_optional(int64_t n, int64_t grain_size, const void * a, daal::functype func)
 {
     load_daal_thr_dll();
-    static _daal_threader_for_t _daal_threader_for_optional_ptr = (_daal_threader_for_t)load_daal_thr_func("_daal_threader_for_optional");
-    _daal_threader_for_optional_ptr(n, threads_request, a, func);
+    static _daal_threader_for_optional_t _daal_threader_for_optional_ptr =
+        (_daal_threader_for_optional_t)load_daal_thr_func("_daal_threader_for_optional");
+    _daal_threader_for_optional_ptr(n, grain_size, a, func);
 }
 
 DAAL_EXPORT int64_t _daal_parallel_reduce_int32_int64(int32_t n, int64_t init, const void * a, daal::loop_functype_int32_int64 loop_func,
@@ -306,11 +319,11 @@ DAAL_EXPORT int64_t _daal_parallel_reduce_int32ptr_int64_simple(const int32_t *
     return _daal_parallel_reduce_int32ptr_int64_simple_ptr(begin, end, init, a, loop_func, b, reduction_func);
 }
 
-DAAL_EXPORT void _daal_threader_for_break(int n, int threads_request, const void * a, daal::functype_break func)
+DAAL_EXPORT void _daal_threader_for_break(int64_t n, int64_t grain_size, const void * a, daal::functype_break func)
 {
     load_daal_thr_dll();
     static _daal_threader_for_break_t _daal_threader_for_break_ptr = (_daal_threader_for_break_t)load_daal_thr_func("_daal_threader_for_break");
-    _daal_threader_for_break_ptr(n, threads_request, a, func);
+    _daal_threader_for_break_ptr(n, grain_size, a, func);
 }
 
 DAAL_EXPORT int _daal_threader_get_max_threads()

cpp/daal/src/threading/threading.cpp

@@ -117,33 +117,11 @@ DAAL_EXPORT size_t _setNumberOfThreads(const size_t numThreads, void ** globalCo
     return 1;
 }
 
-DAAL_EXPORT void _daal_threader_for(int n, int reserved, const void * a, daal::functype func)
+DAAL_EXPORT void _daal_threader_for(int64_t n, int64_t grain_size, const void * a, daal::functype func)
 {
     if (daal::threader_env()->getNumberOfThreads() > 1)
     {
-        tbb::parallel_for(tbb::blocked_range<int>(0, n, 1), [&](tbb::blocked_range<int> r) {
-            int i;
-            for (i = r.begin(); i < r.end(); i++)
-            {
-                func(i, a);
-            }
-        });
-    }
-    else
-    {
-        int i;
-        for (i = 0; i < n; i++)
-        {
-            func(i, a);
-        }
-    }
-}
-
-DAAL_EXPORT void _daal_threader_for_int64(int64_t n, const void * a, daal::functype_int64 func)
-{
-    if (daal::threader_env()->getNumberOfThreads() > 1)
-    {
-        tbb::parallel_for(tbb::blocked_range<int64_t>(0, n, 1), [&](tbb::blocked_range<int64_t> r) {
+        tbb::parallel_for(tbb::blocked_range<int64_t>(0, n, grain_size), [&](tbb::blocked_range<int64_t> r) {
             int64_t i;
             for (i = r.begin(); i < r.end(); i++)
             {
@@ -161,27 +139,14 @@ DAAL_EXPORT void _daal_threader_for_int64(int64_t n, const void * a, daal::funct
     }
 }
 
-DAAL_EXPORT void _daal_threader_for_blocked_size(size_t n, size_t block, const void * a, daal::functype_blocked_size func)
-{
-    if (daal::threader_env()->getNumberOfThreads() > 1)
-    {
-        tbb::parallel_for(tbb::blocked_range<size_t>(0ul, n, block),
-                          [=](tbb::blocked_range<size_t> r) -> void { return func(r.begin(), r.end(), a); });
-    }
-    else
-    {
-        func(0ul, n, a);
-    }
-}
-
-DAAL_EXPORT void _daal_threader_for_simple(int n, int reserved, const void * a, daal::functype func)
+DAAL_EXPORT void _daal_threader_for_simple(int64_t n, int64_t grain_size, const void * a, daal::functype func)
 {
     if (daal::threader_env()->getNumberOfThreads() > 1)
     {
         tbb::parallel_for(
-            tbb::blocked_range<int>(0, n, 1),
-            [&](tbb::blocked_range<int> r) {
-                int i;
+            tbb::blocked_range<int64_t>(0, n, grain_size),
+            [&](tbb::blocked_range<int64_t> r) {
+                int64_t i;
                 for (i = r.begin(); i < r.end(); i++)
                 {
                     func(i, a);
@@ -191,20 +156,20 @@ DAAL_EXPORT void _daal_threader_for_simple(int n, int reserved, const void * a,
     }
     else
     {
-        int i;
+        int64_t i;
         for (i = 0; i < n; i++)
         {
             func(i, a);
         }
     }
 }
 
-DAAL_EXPORT void _daal_threader_for_int32ptr(const int * begin, const int * end, const void * a, daal::functype_int32ptr func)
+DAAL_EXPORT void _daal_threader_for_int64ptr(const int64_t * begin, const int64_t * end, const void * a, daal::functype_int64ptr func)
 {
     if (daal::threader_env()->getNumberOfThreads() > 1)
     {
-        tbb::parallel_for(tbb::blocked_range<const int *>(begin, end, 1), [&](tbb::blocked_range<const int *> r) {
-            const int * i;
+        tbb::parallel_for(tbb::blocked_range<const int64_t *>(begin, end, 1), [&](tbb::blocked_range<const int64_t *> r) {
+            const int64_t * i;
             for (i = r.begin(); i != r.end(); i++)
             {
                 func(i, a);
@@ -213,7 +178,7 @@ DAAL_EXPORT void _daal_threader_for_int32ptr(const int * begin, const int * end,
     }
     else
     {
-        const int * i;
+        const int64_t * i;
         for (i = begin; i != end; ++i)
         {
             func(i, a);
@@ -275,21 +240,21 @@ DAAL_EXPORT int64_t _daal_parallel_reduce_int32ptr_int64_simple(const int32_t *
     }
 }
 
-DAAL_EXPORT void _daal_static_threader_for(size_t n, const void * a, daal::functype_static func)
+DAAL_EXPORT void _daal_static_threader_for(int64_t n, const void * a, daal::functype_static func)
 {
-    const size_t nthreads = std::min(daal::threader_env()->getNumberOfThreads(), static_cast<size_t>(_daal_threader_get_max_threads()));
+    const int64_t nthreads = std::min(daal::threader_env()->getNumberOfThreads(), static_cast<size_t>(_daal_threader_get_max_threads()));
     if (nthreads > 1)
     {
-        const size_t nblocks_per_thread = n / nthreads + !!(n % nthreads);
+        const int64_t nblocks_per_thread = n / nthreads + !!(n % nthreads);
 
         tbb::parallel_for(
-            tbb::blocked_range<size_t>(0, nthreads, 1),
-            [&](tbb::blocked_range<size_t> r) {
-                const size_t tid   = r.begin();
-                const size_t begin = tid * nblocks_per_thread;
-                const size_t end   = n < begin + nblocks_per_thread ? n : begin + nblocks_per_thread;
+            tbb::blocked_range<int64_t>(0, nthreads, 1),
+            [&](tbb::blocked_range<int64_t> r) {
+                const int64_t tid   = r.begin();
+                const int64_t begin = tid * nblocks_per_thread;
+                const int64_t end   = n < begin + nblocks_per_thread ? n : begin + nblocks_per_thread;
 
-                for (size_t i = begin; i < end; ++i)
+                for (int64_t i = begin; i < end; ++i)
                 {
                     func(i, tid, a);
                 }
@@ -298,7 +263,7 @@ DAAL_EXPORT void _daal_static_threader_for(size_t n, const void * a, daal::funct
     }
     else
     {
-        for (size_t i = 0; i < n; i++)
+        for (int64_t i = 0; i < n; i++)
         {
             func(i, 0, a);
         }
@@ -332,50 +297,50 @@ DAAL_PARALLEL_SORT_IMPL(daal::IdxValType<double>, pair_fp64_uint64)
 
 #undef DAAL_PARALLEL_SORT_IMPL
 
-DAAL_EXPORT void _daal_threader_for_blocked(int n, int reserved, const void * a, daal::functype2 func)
+DAAL_EXPORT void _daal_threader_for_blocked(int64_t n, int64_t grain_size, const void * a, daal::functype2 func)
 {
     if (daal::threader_env()->getNumberOfThreads() > 1)
     {
-        tbb::parallel_for(tbb::blocked_range<int>(0, n, 1), [&](tbb::blocked_range<int> r) { func(r.begin(), r.end() - r.begin(), a); });
+        tbb::parallel_for(tbb::blocked_range<int64_t>(0, n, 1), [&](tbb::blocked_range<int64_t> r) { func(r.begin(), r.end() - r.begin(), a); });
     }
     else
     {
         func(0, n, a);
     }
 }
 
-DAAL_EXPORT void _daal_threader_for_optional(int n, int threads_request, const void * a, daal::functype func)
+DAAL_EXPORT void _daal_threader_for_optional(int64_t n, int64_t grain_size, const void * a, daal::functype func)
 {
     if (daal::threader_env()->getNumberOfThreads() > 1)
     {
         if (_daal_is_in_parallel())
         {
-            int i;
+            int64_t i;
             for (i = 0; i < n; i++)
             {
                 func(i, a);
             }
         }
         else
         {
-            _daal_threader_for(n, threads_request, a, func);
+            _daal_threader_for(n, grain_size, a, func);
         }
     }
     else
     {
-        _daal_threader_for(n, threads_request, a, func);
+        _daal_threader_for(n, grain_size, a, func);
     }
 }
 
-DAAL_EXPORT void _daal_threader_for_break(int n, int threads_request, const void * a, daal::functype_break func)
+DAAL_EXPORT void _daal_threader_for_break(int64_t n, int64_t grain_size, const void * a, daal::functype_break func)
 {
     if (daal::threader_env()->getNumberOfThreads() > 1)
     {
         tbb::task_group_context context;
         tbb::parallel_for(
-            tbb::blocked_range<int>(0, n, 1),
-            [&](tbb::blocked_range<int> r) {
-                int i;
+            tbb::blocked_range<int64_t>(0, n, 1),
+            [&](tbb::blocked_range<int64_t> r) {
+                int64_t i;
                 for (i = r.begin(); i < r.end(); ++i)
                 {
                     bool needBreak = false;
@@ -387,7 +352,7 @@ DAAL_EXPORT void _daal_threader_for_break(int n, int threads_request, const void
     }
     else
     {
-        int i;
+        int64_t i;
         for (i = 0; i < n; ++i)
         {
             bool needBreak = false;