Adjust testing complexity

NVIDIA · Dec 3, 2021 · 044f49c · 044f49c
1 parent 2a0023d
commit 044f49c
Showing 1 changed file with 64 additions and 67 deletions.
diff --git a/test/test_device_segmented_sort.cu b/test/test_device_segmented_sort.cu
@@ -77,7 +77,7 @@ struct UnwrapHalfAndBfloat16<bfloat16_t>
 };
 #endif
 
-constexpr static int MAX_ITERATIONS = 4;
+constexpr static int MAX_ITERATIONS = 2;
 
 
 class SizeGroupDescription
@@ -1386,93 +1386,90 @@ void InputTestRandom(Input<KeyT, ValueT> &input)
       {
         for (bool sort_buffers: { pointers, double_buffer })
         {
-          for (int iteration = 0; iteration < MAX_ITERATIONS; iteration++)
-          {
-            RandomizeInput(h_keys, h_values);
+          RandomizeInput(h_keys, h_values);
 
 #if STORE_ON_FAILURE
-            auto h_keys_backup = h_keys;
-            auto h_values_backup = h_values;
+          auto h_keys_backup = h_keys;
+        auto h_values_backup = h_values;
 #endif
 
-            input.get_d_keys_vec()   = h_keys;
-            input.get_d_values_vec() = h_values;
+          input.get_d_keys_vec()   = h_keys;
+          input.get_d_values_vec() = h_values;
 
-            cub::DoubleBuffer<KeyT> keys_buffer(input.get_d_keys(), d_keys_output);
-            cub::DoubleBuffer<ValueT> values_buffer(input.get_d_values(), d_values_output);
+          cub::DoubleBuffer<KeyT> keys_buffer(input.get_d_keys(), d_keys_output);
+          cub::DoubleBuffer<ValueT> values_buffer(input.get_d_values(), d_values_output);
 
-            Sort<KeyT, ValueT>(sort_pairs,
-                               sort_descending,
-                               sort_buffers,
-                               stable_sort,
-                               input.get_d_keys(),
-                               d_keys_output,
-                               input.get_d_values(),
-                               d_values_output,
-                               input.get_num_items(),
-                               input.get_num_segments(),
-                               input.get_d_offsets(),
-                               &keys_buffer.selector,
-                               &values_buffer.selector);
+          Sort<KeyT, ValueT>(sort_pairs,
+                             sort_descending,
+                             sort_buffers,
+                             stable_sort,
+                             input.get_d_keys(),
+                             d_keys_output,
+                             input.get_d_values(),
+                             d_values_output,
+                             input.get_num_items(),
+                             input.get_num_segments(),
+                             input.get_d_offsets(),
+                             &keys_buffer.selector,
+                             &values_buffer.selector);
 
-            HostReferenceSort(sort_pairs,
-                              sort_descending,
-                              input.get_num_segments(),
-                              h_offsets,
-                              h_keys,
-                              h_values);
+          HostReferenceSort(sort_pairs,
+                            sort_descending,
+                            input.get_num_segments(),
+                            h_offsets,
+                            h_keys,
+                            h_values);
 
-            if (sort_buffers)
+          if (sort_buffers)
+          {
+            if (keys_buffer.selector)
             {
-              if (keys_buffer.selector)
-              {
-                h_keys_output = keys_output;
-              }
-              else
-              {
-                h_keys_output = input.get_d_keys_vec();
-              }
-
-              if (values_buffer.selector)
-              {
-                h_values_output = values_output;
-              }
-              else
-              {
-                h_values_output = input.get_d_values_vec();
-              }
+              h_keys_output = keys_output;
             }
             else
             {
-              h_keys_output = keys_output;
+              h_keys_output = input.get_d_keys_vec();
+            }
+
+            if (values_buffer.selector)
+            {
               h_values_output = values_output;
             }
+            else
+            {
+              h_values_output = input.get_d_values_vec();
+            }
+          }
+          else
+          {
+            h_keys_output = keys_output;
+            h_values_output = values_output;
+          }
 
-            const bool keys_ok =
-              compare_two_outputs(h_offsets, h_keys, h_keys_output);
+          const bool keys_ok =
+            compare_two_outputs(h_offsets, h_keys, h_keys_output);
 
-            const bool values_ok =
-              sort_pairs
-                ? compare_two_outputs(h_offsets, h_values, h_values_output)
-                : true;
+          const bool values_ok =
+            sort_pairs
+              ? compare_two_outputs(h_offsets, h_values, h_values_output)
+              : true;
 
 #if STORE_ON_FAILURE
-            if (!keys_ok || !values_ok)
-            {
-              DumpInput<KeyT, ValueT>(sort_pairs,
-                                      sort_descending,
-                                      sort_buffers,
-                                      input,
-                                      h_keys_backup,
-                                      h_values_backup);
-            }
+          if (!keys_ok || !values_ok)
+        {
+        DumpInput<KeyT, ValueT>(sort_pairs,
+        sort_descending,
+        sort_buffers,
+        input,
+        h_keys_backup,
+        h_values_backup);
+        }
 #endif
 
 AssertTrue(keys_ok);
-            AssertTrue(values_ok);
+          AssertTrue(values_ok);
 
-            input.shuffle();
-          }
+          input.shuffle();
         }
       }
     }
@@ -1611,7 +1608,7 @@ template <typename KeyT,
 void RandomTest(int min_segments,
                 int max_segments)
 {
-  const int max_items = 10000000;
+  const int max_items = 4200000;
 
   for (int iteration = 0; iteration < MAX_ITERATIONS; iteration++)
   {