diff --git a/test/dfs/Makefile b/test/dfs/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..c774d4eaaf91987cf1193955297ace1e36d45a26
--- /dev/null
+++ b/test/dfs/Makefile
@@ -0,0 +1,37 @@
+# Time-stamp: <modified the 26/03/2019 (at 14:43) by Erwan Jahier>
+
+
+test: test0 lurette0
+test0: cmxs
+ $(sasa) -rif -l 200 g.dot -sd
+
+cmxs: p.cmxs root.cmxs g.lut
+
+sim2chrogtk: g.rif
+ sim2chrogtk -ecran -in $< > /dev/null
+
+gnuplot: g.rif
+ gnuplot-rif $<
+
+
+lurette0:cmxs
+ lurette -o lurette.rif \
+ -env "$(sasa) g.dot -custd -rif" \
+ -sut "lutin g.lut -n distributed"
+
+lurette: lurette0
+ sim2chrogtk -ecran -in lurette.rif > /dev/null
+ gnuplot-rif lurette.rif
+
+rdbg: cmxs g.lut
+ rdbg
+
+rdbg0: cmxs g.lut
+ rdbg -o lurette.rif \
+ -env "$(sasa) g.dot -custd -rif" \
+ -sut-nd "lutin g.lut -n distributed"
+
+
+
+-include ../Makefile.inc
+
diff --git a/test/dfs/g.dot b/test/dfs/g.dot
new file mode 100644
index 0000000000000000000000000000000000000000..15d310ced3824e4d7209ac9f1f704d9a48a78a64
--- /dev/null
+++ b/test/dfs/g.dot
@@ -0,0 +1,18 @@
+graph {
+
+ p1 [algo="p.cmxs"]
+ p2 [algo="p.cmxs"]
+ p3 [algo="root.cmxs"]
+ p4 [algo="p.cmxs"]
+ p5 [algo="p.cmxs"]
+ p6 [algo="p.cmxs"]
+ p7 [algo="p.cmxs"]
+ p8 [algo="p.cmxs"]
+ p9 [algo="p.cmxs"]
+ p10 [algo="p.cmxs"]
+
+ p1 -- p2 -- p3 -- p4
+ p2 -- p4 -- p5 --p2
+ p3 -- p6 -- p7 -- p8 -- p9 -- p10 --p6
+
+}
diff --git a/test/dfs/p.ml b/test/dfs/p.ml
new file mode 100644
index 0000000000000000000000000000000000000000..1c49e6d6efdced5a9f0dba5faa3eb5be06d37b3a
--- /dev/null
+++ b/test/dfs/p.ml
@@ -0,0 +1,113 @@
+(* Time-stamp: <modified the 27/03/2019 (at 17:11) by Erwan Jahier> *)
+
+(* cf Collin-Dolex-94 *)
+
+open Algo
+
+let delta=10
+let vars = ["path",(At (It,delta)); "par",Nt]
+let actions = ["a"]
+
+let (init_vars: neighbor list -> local_env) =
+ fun nl -> function
+ | "path" -> A (Array.make delta (I (-1)))
+ | "par" -> N (try Random.int ((List.length nl)) with _ -> assert false)
+ | _ -> raise Not_found
+
+(* casting *)
+let i v = match v with I i | N i -> i | _ -> assert false
+let (a:value -> value array) = function A a -> a | _ -> assert false
+
+let str_of_array a =
+ let l = List.map Algo.value_to_string (Array.to_list a) in
+ "["^(String.concat "," l)^"]"
+
+let min_path al =
+ match al with
+ | [] -> assert false
+ | x::t -> List.fold_left min x t
+
+let (get_paths: neighbor list -> local_env -> value array list) =
+ fun nl e ->
+ List.mapi (fun alpha_i n -> a (n.lenv "path")) nl
+
+let (enable_f:neighbor list -> local_env -> action list) =
+ fun _nl _e -> ["a"]
+
+
+(* The index of the first negative elt in a starting from i. returns
+ the size of the a if none is found *)
+let rec end_of_a a i =
+ if i=delta then delta else
+ if a.(i) < I 0 then i else end_of_a a (i+1)
+
+
+(* concat and truncate *)
+let (concat_path : value array -> int -> value array) =
+ fun a alpha ->
+ let s = Array.length a in
+ let a = Array.copy a in (* ouch! *)
+ let last = end_of_a a 1 in
+ if last=s then (
+ for i = 1 to s-1 do
+ a.(i-1) <- a.(i)
+ done;
+ a.(s-1) <- I alpha
+ )
+ else
+ a.(last) <- I alpha;
+ a
+
+let equals_up_to p1 p2 i =
+ let res = ref true in
+ for j = 0 to i do
+ res := !res && p1.(j) = p2.(j) ;
+ done;
+ !res
+
+let (get_parent : neighbor list -> value array -> value) =
+ fun nl p ->
+ (* The parent of a process p in the neighbor which path is a
+ subpath of p *)
+ let last_p = end_of_a p 1 in
+ let paths = List.mapi (fun i n -> a (n.lenv "path"), i) nl in
+ let _,parent =
+ match
+ List.find_opt
+ (fun (npath,_) ->
+ let last_n = end_of_a npath 1 in
+ last_n = last_p-1 && equals_up_to npath p (last_n-1)
+ )
+ paths
+ with
+ Some p -> p
+ | None -> [||],(-1) (* may happen before convergence *)
+ in
+ N parent
+
+
+let (step_f : neighbor list -> local_env -> action -> local_env) =
+ fun nl e ->
+ function
+ | "a" ->
+ let paths = get_paths nl e in
+ let paths = List.map2 (fun p n -> concat_path p (n.reply ())) paths nl in
+
+ let path = min_path paths in
+ (
+ function
+ | "path" -> A path
+ | "par" -> get_parent nl path
+ | o -> e o
+ )
+ | _ -> assert false
+
+let () =
+ let algo_id = "p" in
+ Algo.reg_vars algo_id vars;
+ Algo.reg_init_vars algo_id init_vars;
+ Algo.reg_enable algo_id enable_f;
+ Algo.reg_step algo_id step_f;
+ Algo.reg_actions algo_id actions;
+ ()
+
diff --git a/test/dfs/rdbg-session.ml b/test/dfs/rdbg-session.ml
index e6de3d89e15293e25796ed5abe27859d2a7237b7..127d8b94e17a905d3e0da014d00ef08f477d13f6 100644
--- a/test/dfs/rdbg-session.ml
+++ b/test/dfs/rdbg-session.ml
@@ -14,7 +14,7 @@ open Data;;
#require "lutin";;
let plugin_0 =
- let args = ["lutin";"g.lut";"-n";"distributed"] in
+ let args = ["lutin";"g.lut";"-n";"synchronous"] in
let aargs = Array.of_list args in
let plugin = LutinRun.make aargs in
let skip_dbg sl e cont = cont (plugin.step sl) e in
@@ -22,7 +22,7 @@ let plugin_0 =
;;
let plugin_1 =
- let plugin = StdioRun.make "../../_build/install/default/bin/sasa -seed 42 g.dot -custd -rif" in
+ let plugin = StdioRun.make "../../_build/install/default/bin/sasa -l 1000 -vl 1 -seed 42 g.dot -custd -rif" in
plugin
;;
let _ = args.suts <- [Ocaml(plugin_0)];;
@@ -33,7 +33,7 @@ let _ =
args.display_gnuplot <- false;
args.display_sim2chro <- false;
args.rdbg <- true;
- args.step_nb <- 100;
+ args.step_nb <- 1000;
args.output <- "g.rif";
args.cov_file <- "lurette.cov";
args.stop_on_oracle_error <- true;
@@ -55,7 +55,21 @@ let _ = print_string "
let dotfile = "g.dot";;
let p = Topology.read dotfile;;
-let d () = print_dot p dotfile !e;;
+let d () = dot p dotfile !e;;
+let ne () = neato p dotfile !e;;
+let tw () = twopi p dotfile !e;;
+let ci () = circo p dotfile !e;;
+let fd () = fdp p dotfile !e;;
+let sf () = sfdp p dotfile !e;;
+let pa () = patchwork p dotfile !e;;
+let os () = osage p dotfile !e;;
+
+
let sd () = s();d();;
-let nr () = e:=next_round p.nodes dotfile !e; d();;
+let nr () = e:=next_round p.nodes dotfile !e; osage p dotfile !e;;
let _ = n (); d (); ignore (Sys.command ("zathura sasa-g.dot.pdf&"))
+
+(* Convergence is reached when data does not change *)
+let rec go () =
+ let data = !e.data in
+ s(); if data = !e.data then ci () else go () ;;
diff --git a/test/dfs/root.ml b/test/dfs/root.ml
new file mode 100644
index 0000000000000000000000000000000000000000..6f05433143dfb539541897f2935b6e8c13cc63df
--- /dev/null
+++ b/test/dfs/root.ml
@@ -0,0 +1,43 @@
+(* Time-stamp: <modified the 27/03/2019 (at 09:53) by Erwan Jahier> *)
+
+(* cf Collin-Dolex-94 *)
+
+open Algo
+
+let delta=10
+let vars = ["path",(At (It,delta)) ]
+let actions = ["a"]
+
+let (init_vars: neighbor list -> local_env) =
+ fun nl -> function
+ | "path" -> A (Array.make delta (I (-1)))
+ | "par" -> N (try Random.int ((List.length nl)) with _ -> assert false)
+ | _ -> raise Not_found
+
+(* casting *)
+let i v = match v with I i | N i -> i | _ -> assert false
+
+
+let (enable_f:neighbor list -> local_env -> action list) =
+ fun _nl _e -> ["a"]
+
+
+let (step_f : neighbor list -> local_env -> action -> local_env) =
+ fun nl e ->
+ function
+ | "a" -> (
+ function
+ | "path" -> A (Array.make delta (I (-1)))
+ | o -> e o
+ )
+ | _ -> assert false
+
+let () =
+ let algo_id = "root" in
+ Algo.reg_vars algo_id vars;
+ Algo.reg_init_vars algo_id init_vars;
+ Algo.reg_enable algo_id enable_f;
+ Algo.reg_step algo_id step_f;
+ Algo.reg_actions algo_id actions;
+ ()
+