Remove unnecessary checks for non-default parallelization schemes.

These checks are a historical artifact of the time when these functions lived in tatami itself, and are largely redundant with the existing checks for correct behavior of parallelize(). We also switch to int instead of size_t for the thread ID to avoid an unnecessary cast inside of parallelize().
tatami-inc · Aug 26, 2024 · 2baa749 · 2baa749
1 parent 87ed962
commit 2baa749
Show file tree

Hide file tree

Showing 15 changed files with 40 additions and 146 deletions.
diff --git a/include/tatami_stats/grouped_sums.hpp b/include/tatami_stats/grouped_sums.hpp
@@ -106,7 +106,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, const Group_* grou
             tatami::Options opt;
             opt.sparse_ordered_index = false; 
 
-            tatami::parallelize([&](size_t thread, Index_ start, Index_ len) -> void {
+            tatami::parallelize([&](int thread, Index_ start, Index_ len) -> void {
                 std::vector<sums::RunningSparse<Output_, Value_, Index_> > runners;
                 runners.reserve(num_groups);
                 std::vector<LocalOutputBuffer<Output_> > local_output;
@@ -167,7 +167,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, const Group_* grou
             }, dim, sopt.num_threads);
 
         } else {
-            tatami::parallelize([&](size_t thread, Index_ start, Index_ len) -> void {
+            tatami::parallelize([&](int thread, Index_ start, Index_ len) -> void {
                 std::vector<sums::RunningDense<Output_, Value_, Index_> > runners;
                 runners.reserve(num_groups);
                 std::vector<LocalOutputBuffer<Output_> > local_output;

diff --git a/include/tatami_stats/grouped_variances.hpp b/include/tatami_stats/grouped_variances.hpp
@@ -322,7 +322,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, const Group_* grou
             tatami::Options opt;
             opt.sparse_ordered_index = false; 
 
-            tatami::parallelize([&](size_t thread, Index_ start, Index_ len) -> void {
+            tatami::parallelize([&](int thread, Index_ start, Index_ len) -> void {
                 std::vector<variances::RunningSparse<Output_, Value_, Index_> > runners;
                 runners.reserve(num_groups);
                 std::vector<LocalOutputBuffer<Output_> > local_var_output;
@@ -382,7 +382,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, const Group_* grou
             }, dim, sopt.num_threads);
 
         } else {
-            tatami::parallelize([&](size_t thread, Index_ start, Index_ len) -> void {
+            tatami::parallelize([&](int thread, Index_ start, Index_ len) -> void {
                 std::vector<variances::RunningDense<Output_, Value_, Index_> > runners;
                 runners.reserve(num_groups);
                 std::vector<LocalOutputBuffer<Output_> > local_var_output;

diff --git a/include/tatami_stats/ranges.hpp b/include/tatami_stats/ranges.hpp
@@ -352,7 +352,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* min_out,
 
         if (direct) {
             opt.sparse_extract_index = false;
-            tatami::parallelize([&](size_t, Index_ s, Index_ l) {
+            tatami::parallelize([&](int, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<true>(p, row, s, l, opt);
                 std::vector<Value_> vbuffer(otherdim);
                 for (Index_ x = 0; x < l; ++x) {
@@ -367,7 +367,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* min_out,
             }, dim, ropt.num_threads);
 
         } else {
-            tatami::parallelize([&](size_t thread, Index_ s, Index_ l) {
+            tatami::parallelize([&](int thread, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<true>(p, !row, static_cast<Index_>(0), otherdim, s, l, opt);
                 std::vector<Value_> vbuffer(l);
                 std::vector<Index_> ibuffer(l);
@@ -400,7 +400,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* min_out,
 
     } else {
         if (direct) {
-            tatami::parallelize([&](size_t, Index_ s, Index_ l) {
+            tatami::parallelize([&](int, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<false>(p, row, s, l);
                 std::vector<Value_> buffer(otherdim);
                 for (Index_ x = 0; x < l; ++x) {
@@ -415,7 +415,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* min_out,
             }, dim, ropt.num_threads);
 
         } else {
-            tatami::parallelize([&](size_t thread, Index_ s, Index_ l) {
+            tatami::parallelize([&](int thread, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<false>(p, !row, static_cast<Index_>(0), otherdim, s, l);
                 std::vector<Value_> buffer(l);
 

diff --git a/include/tatami_stats/sums.hpp b/include/tatami_stats/sums.hpp
@@ -213,7 +213,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, c
             tatami::Options opt;
             opt.sparse_extract_index = false;
 
-            tatami::parallelize([&](size_t, Index_ s, Index_ l) {
+            tatami::parallelize([&](int, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<true>(p, row, s, l, opt);
                 std::vector<Value_> vbuffer(otherdim);
                 for (Index_ x = 0; x < l; ++x) {
@@ -226,7 +226,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, c
             tatami::Options opt;
             opt.sparse_ordered_index = false;
 
-            tatami::parallelize([&](size_t thread, Index_ s, Index_ l) {
+            tatami::parallelize([&](int thread, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<true>(p, !row, static_cast<Index_>(0), otherdim, s, l, opt);
                 std::vector<Value_> vbuffer(l);
                 std::vector<Index_> ibuffer(l);
@@ -245,7 +245,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, c
 
     } else {
         if (direct) {
-            tatami::parallelize([&](size_t, Index_ s, Index_ l) {
+            tatami::parallelize([&](int, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<false>(p, row, s, l);
                 std::vector<Value_> buffer(otherdim);
                 for (Index_ x = 0; x < l; ++x) {
@@ -255,7 +255,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, c
             }, dim, sopt.num_threads);
 
         } else {
-            tatami::parallelize([&](size_t thread, Index_ s, Index_ l) {
+            tatami::parallelize([&](int thread, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<false>(p, !row, static_cast<Index_>(0), otherdim, s, l);
                 std::vector<Value_> buffer(l);
 

diff --git a/include/tatami_stats/variances.hpp b/include/tatami_stats/variances.hpp
@@ -402,7 +402,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, c
         if (direct) {
             tatami::Options opt;
             opt.sparse_extract_index = false;
-            tatami::parallelize([&](size_t, Index_ s, Index_ l) {
+            tatami::parallelize([&](int, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<true>(p, row, s, l);
                 std::vector<Value_> vbuffer(otherdim);
                 for (Index_ x = 0; x < l; ++x) {
@@ -412,7 +412,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, c
             }, dim, vopt.num_threads);
 
         } else {
-            tatami::parallelize([&](size_t thread, Index_ s, Index_ l) {
+            tatami::parallelize([&](int thread, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<true>(p, !row, static_cast<Index_>(0), otherdim, s, l);
                 std::vector<Value_> vbuffer(l);
                 std::vector<Index_> ibuffer(l);
@@ -433,7 +433,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, c
 
     } else {
         if (direct) {
-            tatami::parallelize([&](size_t, Index_ s, Index_ l) {
+            tatami::parallelize([&](int, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<false>(p, row, s, l);
                 std::vector<Value_> buffer(otherdim);
                 for (Index_ x = 0; x < l; ++x) {
@@ -443,7 +443,7 @@ void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, c
             }, dim, vopt.num_threads);
 
         } else {
-            tatami::parallelize([&](size_t thread, Index_ s, Index_ l) {
+            tatami::parallelize([&](int thread, Index_ s, Index_ l) {
                 auto ext = tatami::consecutive_extractor<false>(p, !row, static_cast<Index_>(0), otherdim, s, l);
                 std::vector<Value_> buffer(l);
 

diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
@@ -14,51 +14,32 @@ FetchContent_MakeAvailable(googletest)
 
 enable_testing()
 
-include(GoogleTest)
+add_executable(
+    libtest
+    src/sums.cpp
+    src/variances.cpp
+    src/medians.cpp
+    src/ranges.cpp
+    src/counts.cpp
+    src/grouped_medians.cpp
+    src/grouped_sums.cpp
+    src/grouped_variances.cpp
+    src/utils.cpp
+)
+
+target_link_libraries(
+    libtest
+    gtest_main
+    tatami_stats
+)
+
+target_compile_options(libtest PRIVATE -Wall -Wextra -Wpedantic -Werror)
 
 set(CODE_COVERAGE OFF CACHE BOOL "Enable coverage testing")
-set(DO_CODE_COVERAGE OFF)
 if(CODE_COVERAGE AND CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
-    set(DO_CODE_COVERAGE ON)
+    target_compile_options(libtest PRIVATE -O0 -g --coverage)
+    target_link_options(libtest PRIVATE --coverage)
 endif()
 
-macro(create_test target)
-    add_executable(
-        ${target}
-        src/sums.cpp
-        src/variances.cpp
-        src/medians.cpp
-        src/ranges.cpp
-        src/counts.cpp
-        src/grouped_medians.cpp
-        src/grouped_sums.cpp
-        src/grouped_variances.cpp
-        src/utils.cpp
-    )
-
-    target_link_libraries(
-        ${target}
-        gtest_main
-        tatami_stats
-    )
-
-    target_compile_options(${target} PRIVATE -Wall -Wextra -Wpedantic -Werror)
-
-    if(DO_CODE_COVERAGE)
-        target_compile_options(${target} PRIVATE -O0 -g --coverage)
-        target_link_options(${target} PRIVATE --coverage)
-    endif()
-
-    gtest_discover_tests(${target})
-endmacro()
-
-create_test(libtest)
-
-create_test(cuspartest)
-target_compile_definitions(cuspartest PRIVATE CUSTOM_PARALLEL_TEST=1)
-
-find_package(OpenMP)
-if(OpenMP_FOUND)
-    create_test(omptest)
-    target_link_libraries(omptest OpenMP::OpenMP_CXX)
-endif()
+include(GoogleTest)
+gtest_discover_tests(libtest)
diff --git a/tests/src/counts.cpp b/tests/src/counts.cpp
@@ -2,11 +2,6 @@
 
 #include <vector>
 
-#ifdef CUSTOM_PARALLEL_TEST
-// Put this before any tatami imports.
-#include "custom_parallel.h"
-#endif
-
 #include "tatami_stats/counts.hpp"
 #include "tatami_test/tatami_test.hpp"
 

diff --git a/tests/src/custom_parallel.h b/tests/src/custom_parallel.h
diff --git a/tests/src/grouped_medians.cpp b/tests/src/grouped_medians.cpp
@@ -2,11 +2,6 @@
 
 #include <vector>
 
-#ifdef CUSTOM_PARALLEL_TEST
-// Put this before any tatami imports.
-#include "custom_parallel.h"
-#endif
-
 #include "tatami/tatami.hpp"
 #include "tatami_stats/grouped_medians.hpp"
 #include "tatami_test/tatami_test.hpp"

diff --git a/tests/src/grouped_sums.cpp b/tests/src/grouped_sums.cpp
@@ -2,11 +2,6 @@
 
 #include <vector>
 
-#ifdef CUSTOM_PARALLEL_TEST
-// Put this before any tatami imports.
-#include "custom_parallel.h"
-#endif
-
 #include "tatami_stats/grouped_sums.hpp"
 #include "tatami_stats/sums.hpp"
 #include "tatami_test/tatami_test.hpp"

diff --git a/tests/src/grouped_variances.cpp b/tests/src/grouped_variances.cpp
@@ -2,11 +2,6 @@
 
 #include <vector>
 
-#ifdef CUSTOM_PARALLEL_TEST
-// Put this before any tatami imports.
-#include "custom_parallel.h"
-#endif
-
 #include "tatami_stats/grouped_variances.hpp"
 #include "tatami_stats/variances.hpp"
 #include "tatami_test/tatami_test.hpp"

diff --git a/tests/src/medians.cpp b/tests/src/medians.cpp
@@ -2,11 +2,6 @@
 
 #include <vector>
 
-#ifdef CUSTOM_PARALLEL_TEST
-// Put this before any tatami imports.
-#include "custom_parallel.h"
-#endif
-
 #include "tatami_stats/medians.hpp"
 #include "tatami_test/tatami_test.hpp"
 

diff --git a/tests/src/ranges.cpp b/tests/src/ranges.cpp
@@ -2,11 +2,6 @@
 
 #include <vector>
 
-#ifdef CUSTOM_PARALLEL_TEST
-// Put this before any tatami imports.
-#include "custom_parallel.h"
-#endif
-
 #include "tatami_stats/ranges.hpp"
 #include "tatami_test/tatami_test.hpp"
 

diff --git a/tests/src/sums.cpp b/tests/src/sums.cpp
@@ -2,11 +2,6 @@
 
 #include <vector>
 
-#ifdef CUSTOM_PARALLEL_TEST
-// Put this before any tatami imports.
-#include "custom_parallel.h"
-#endif
-
 #include "tatami_stats/sums.hpp"
 #include "tatami_test/tatami_test.hpp"
 #include "utils.h"

diff --git a/tests/src/variances.cpp b/tests/src/variances.cpp
@@ -2,11 +2,6 @@
 
 #include <vector>
 
-#ifdef CUSTOM_PARALLEL_TEST
-// Put this before any tatami imports.
-#include "custom_parallel.h"
-#endif
-
 #include "utils.h"
 #include "tatami_stats/variances.hpp"
 #include "tatami_test/tatami_test.hpp"