[CN-Test-Gen] Control backtracks from size splits

ZippeyKeys12 · ZippeyKeys12 · commit dc6bf28f7807 · 2024-12-04T21:02:14.000-05:00
diff --git a/backend/cn/bin/main.ml b/backend/cn/bin/main.ml
@@ -450,6 +450,7 @@ let run_tests
   allowed_depth_failures
   max_generator_size
   random_size_splits
+  allowed_size_split_backtracks
   sized_null
   coverage
   disable_passes
@@ -520,6 +521,7 @@ let run_tests
               allowed_depth_failures;
               max_generator_size;
               random_size_splits;
+              allowed_size_split_backtracks;
               sized_null;
               coverage;
               disable_passes
@@ -1007,6 +1009,17 @@ module Testing_flags = struct
     Arg.(value & flag & info [ "random-size-splits" ] ~doc)
 
 
+  let allowed_size_split_backtracks =
+    let doc =
+      "Set the maximum attempts to split up a generator's size (between recursive calls) \
+       before backtracking further, during input generation"
+    in
+    Arg.(
+      value
+      & opt (some int) TestGeneration.default_cfg.allowed_size_split_backtracks
+      & info [ "allowed-size-split-backtracks" ] ~doc)
+
+
   let sized_null =
     let doc =
       "Scale the likelihood of [NULL] proportionally for a desired size (1/n for size n)"
@@ -1070,6 +1083,7 @@ let testing_cmd =
     $ Testing_flags.allowed_depth_failures
     $ Testing_flags.max_generator_size
     $ Testing_flags.random_size_splits
+    $ Testing_flags.allowed_size_split_backtracks
     $ Testing_flags.sized_null
     $ Testing_flags.coverage
     $ Testing_flags.disable_passes
diff --git a/backend/cn/lib/testGeneration/specTests.ml b/backend/cn/lib/testGeneration/specTests.ml
@@ -475,6 +475,13 @@ let compile_script ~(output_dir : string) ~(test_file : string) : Pp.document =
           |> Option.map (fun allowed_depth_failures ->
             [ "--allowed-depth-failures"; string_of_int allowed_depth_failures ])
           |> Option.to_list
+          |> List.flatten)
+       @ (Config.has_allowed_size_split_backtracks ()
+          |> Option.map (fun allowed_size_split_backtracks ->
+            [ "--allowed-size-split-backtracks";
+              string_of_int allowed_size_split_backtracks
+            ])
+          |> Option.to_list
           |> List.flatten))
   in
   cmd
diff --git a/backend/cn/lib/testGeneration/testGenConfig.ml b/backend/cn/lib/testGeneration/testGenConfig.ml
@@ -15,6 +15,7 @@ type t =
     allowed_depth_failures : int option;
     max_generator_size : int option;
     random_size_splits : bool;
+    allowed_size_split_backtracks : int option;
     sized_null : bool;
     coverage : bool;
     disable_passes : string list
@@ -35,6 +36,7 @@ let default =
     allowed_depth_failures = None;
     max_generator_size = None;
     random_size_splits = false;
+    allowed_size_split_backtracks = None;
     sized_null = false;
     coverage = false;
     disable_passes = []
@@ -73,6 +75,8 @@ let has_max_generator_size () = !instance.max_generator_size
 
 let is_random_size_splits () = !instance.random_size_splits
 
+let has_allowed_size_split_backtracks () = !instance.allowed_size_split_backtracks
+
 let is_sized_null () = !instance.sized_null
 
 let is_coverage () = !instance.coverage
diff --git a/backend/cn/lib/testGeneration/testGenConfig.mli b/backend/cn/lib/testGeneration/testGenConfig.mli
@@ -15,6 +15,7 @@ type t =
     allowed_depth_failures : int option;
     max_generator_size : int option;
     random_size_splits : bool;
+    allowed_size_split_backtracks : int option;
     sized_null : bool;
     coverage : bool;
     disable_passes : string list
@@ -52,6 +53,8 @@ val has_max_generator_size : unit -> int option
 
 val is_random_size_splits : unit -> bool
 
+val has_allowed_size_split_backtracks : unit -> int option
+
 val is_sized_null : unit -> bool
 
 val is_coverage : unit -> bool
diff --git a/runtime/libcn/include/cn-testing/dsl.h b/runtime/libcn/include/cn-testing/dsl.h
@@ -240,6 +240,7 @@
     urn_free(tmp##_urn);                                                                \
 
 #define CN_GEN_SPLIT_BEGIN(tmp, size, ...)                                              \
+    int tmp##_backtracks = cn_gen_get_size_split_backtracks_allowed();                  \
     alloc_checkpoint tmp##_checkpoint = alloc_save_checkpoint();                        \
     void *tmp##_alloc_checkpoint = cn_gen_alloc_save();                                 \
     void *tmp##_ownership_checkpoint = cn_gen_ownership_save();                         \
@@ -254,7 +255,7 @@
 #define CN_GEN_SPLIT_END(ty, tmp, size, last_var, ...)                                  \
         if (count >= size) {                                                            \
             cn_gen_backtrack_depth_exceeded();                                          \
-            char* toAdd[] = { __VA_ARGS__, NULL };                                      \
+            char* toAdd[] = { __VA_ARGS__ };                                            \
             cn_gen_backtrack_relevant_add_many(toAdd);                                  \
             goto cn_label_##last_var##_backtrack;                                       \
         }                                                                               \
@@ -275,6 +276,12 @@
         cn_gen_alloc_restore(tmp##_alloc_checkpoint);                                   \
         cn_gen_ownership_restore(tmp##_ownership_checkpoint);                           \
         if (cn_gen_backtrack_relevant_contains(#tmp)) {                                 \
+            char* toAdd[] = { __VA_ARGS__ };                                            \
+            cn_gen_backtrack_relevant_add_many(toAdd);                                  \
+            if (tmp##_backtracks <= 0) {                                                \
+                goto cn_label_##last_var##_backtrack;                                   \
+            }                                                                           \
+            tmp##_backtracks--;                                                         \
             cn_gen_backtrack_reset();                                                   \
             goto cn_label_##tmp##_gen;                                                  \
         } else {                                                                        \
diff --git a/runtime/libcn/include/cn-testing/size.h b/runtime/libcn/include/cn-testing/size.h
@@ -15,3 +15,6 @@ void cn_gen_decrement_depth();
 
 void cn_gen_set_depth_failures_allowed(uint16_t allowed);
 uint16_t cn_gen_get_depth_failures_allowed();
+
+void cn_gen_set_size_split_backtracks_allowed(uint16_t allowed);
+uint16_t cn_gen_get_size_split_backtracks_allowed();
diff --git a/runtime/libcn/src/cn-testing/size.c b/runtime/libcn/src/cn-testing/size.c
@@ -52,3 +52,13 @@ void cn_gen_set_depth_failures_allowed(uint16_t allowed) {
 uint16_t cn_gen_get_depth_failures_allowed() {
     return depth_failures_allowed;
 }
+
+static uint16_t size_split_backtracks_allowed = 0;
+
+void cn_gen_set_size_split_backtracks_allowed(uint16_t allowed) {
+    size_split_backtracks_allowed = allowed;
+}
+
+uint16_t cn_gen_get_size_split_backtracks_allowed() {
+    return size_split_backtracks_allowed;
+}
diff --git a/runtime/libcn/src/cn-testing/test.c b/runtime/libcn/src/cn-testing/test.c
@@ -105,6 +105,10 @@ int cn_test_main(int argc, char* argv[]) {
             cn_gen_set_depth_failures_allowed(strtoul(argv[i + 1], NULL, 10));
             i++;
         }
+        else if (strcmp("--allowed-size-split-backtracks", arg) == 0) {
+            cn_gen_set_size_split_backtracks_allowed(strtoul(argv[i + 1], NULL, 10));
+            i++;
+        }
     }
 
     if (interactive) {
diff --git a/tests/run-cn-test-gen.sh b/tests/run-cn-test-gen.sh
@@ -27,7 +27,7 @@ function separator() {
   printf '\n\n'
 }
 
-CONFIGS=("--coverage" "--sized-null" "--random-size-splits")
+CONFIGS=("--coverage" "--sized-null" "--random-size-splits" "--random-size-splits --allowed-size-split-backtracks=10")
 
 # For each configuration
 for CONFIG in ${CONFIGS[@]}; do

Original file line number	Diff line number	Diff line change
`@@ -105,6 +105,10 @@ int cn_test_main(int argc, char* argv[]) {`
`105`	`105`	`cn_gen_set_depth_failures_allowed(strtoul(argv[i + 1], NULL, 10));`
`106`	`106`	`i++;`
`107`	`107`	`}`
	`108`	`+ else if (strcmp("--allowed-size-split-backtracks", arg) == 0) {`
	`109`	`+ cn_gen_set_size_split_backtracks_allowed(strtoul(argv[i + 1], NULL, 10));`
	`110`	`+ i++;`
	`111`	`+ }`
`108`	`112`	`}`
`109`	`113`
`110`	`114`	`if (interactive) {`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ function separator() {`
`27`	`27`	`printf '\n\n'`
`28`	`28`	`}`
`29`	`29`
`30`		`-CONFIGS=("--coverage" "--sized-null" "--random-size-splits")`
	`30`	`+CONFIGS=("--coverage" "--sized-null" "--random-size-splits" "--random-size-splits --allowed-size-split-backtracks=10")`
`31`	`31`
`32`	`32`	`# For each configuration`
`33`	`33`	`for CONFIG in ${CONFIGS[@]}; do`