Generate less nodes in 32-bit architectures

In 32-bit architectures, the bounds on the number of domains and threads
that can be spawned is much lower that on 64-bit architectures (due to
the much smaller virtual space and the hard limit set on the number of
simultaneous domains), so adjust tests accordingly

Author: shym

src/domain/domain_joingraph.ml

@@ -157,8 +157,12 @@ let test_atomic_work ~domain_bound =
              (*Printf.printf "main domain %i -- joining %s success\n%!" (Domain.self () :> int) tgt_id*)
          ) ps;
        Atomic.get a = test_input.num_domains)
+
+let bound_tak = if Sys.word_size == 64 then 100 else 8
+let bound_atomic = if Sys.word_size == 64 then 250 else 8
+
 ;;
 QCheck_base_runner.run_tests_main
-  [test_tak_work ~domain_bound:100(*8*);
-   test_atomic_work ~domain_bound:250(*8*)
+  [test_tak_work ~domain_bound:bound_tak;
+   test_atomic_work ~domain_bound:bound_atomic
   ]

src/domain/domain_spawntree.ml

@@ -84,5 +84,11 @@ let t ~max_height ~max_degree = Test.make
             then true
             else (Printf.printf "Failure \"%s\"\n%!" s; false)
        ))
+
+let test =
+  if Sys.word_size == 64
+  then t ~max_height:5 ~max_degree:10
+  else t ~max_height:3 ~max_degree:3
+
 ;;
-QCheck_base_runner.run_tests_main [t ~max_height:5 ~max_degree:10]
+QCheck_base_runner.run_tests_main [test]

src/thread/thread_createtree.ml

@@ -73,5 +73,11 @@ let t ~max_height ~max_degree = Test.make
        let a = Atomic.make 0 in
        let () = thread_interp a c in
        Atomic.get a = interp 0 c)
+
+let test =
+  if Sys.word_size == 64
+  then t ~max_height:5 ~max_degree:10
+  else t ~max_height:3 ~max_degree:3
+
 ;;
-QCheck_base_runner.run_tests_main [t ~max_height:5 ~max_degree:10]
+QCheck_base_runner.run_tests_main [test]

src/thread/thread_joingraph.ml

@@ -116,8 +116,12 @@ let test_atomic_work ~thread_bound =
              Thread.join p;
          ) ps;
        Atomic.get a = test_input.num_threads)
+
+let bound_tak = if Sys.word_size == 64 then 100 else 16
+let bound_atomic = if Sys.word_size == 64 then 250 else 16
+
 ;;
 QCheck_base_runner.run_tests_main
-  [test_tak_work    ~thread_bound:100(*8*);
-   test_atomic_work ~thread_bound:250(*8*)
+  [test_tak_work    ~thread_bound:bound_tak;
+   test_atomic_work ~thread_bound:bound_atomic
   ]

src/threadomain/threadomain.ml

@@ -160,10 +160,14 @@ let run_all_nodes sj =
   Array.for_all (fun h -> h = NoHdl) hdls.handles
    && Atomic.get global = sz
 
+let nb_nodes =
+  let max = if Sys.word_size == 64 then 100 else 16 in
+  Gen.int_range 2 max
+
 let main_test = Test.make ~name:"Mash up of threads and domains"
                           ~count:500
                           ~print:show_spawn_join
-                          (Gen.sized_size (Gen.int_range 2 100) gen_spawn_join)
+                          (Gen.sized_size nb_nodes gen_spawn_join)
                           run_all_nodes
                           (* to debug deadlocks: *)
                           (* (Util.fork_prop_with_timeout 1 run_all_nodes) *)