Test: add a new example implementing a DFS [Collin-Dolev94]

test/dfs/Makefile

+# 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
+

test/dfs/g.dot

+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
+
+}

test/dfs/p.ml

+(* 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;
+  ()
+

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 () ;;

test/dfs/root.ml

+(* 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;
+  ()
+