From afa74391fa05ff1a356e78343cc220717d62d710 Mon Sep 17 00:00:00 2001
From: Leandre Lacourt <lacourtl@santel.imag.fr>
Date: Wed, 26 Jun 2024 12:30:45 +0200
Subject: [PATCH] ajout de la recuperation de taches et ecriture dans le yml
(fonctionnel mais pas fini)
---
lib/soc2yaml.ml | 71 +++++++++++++++++++++++++++++------------
lib/socNameC.ml | 85 ++++++++++++++++++++++++++++++++++---------------
2 files changed, 109 insertions(+), 47 deletions(-)
diff --git a/lib/soc2yaml.ml b/lib/soc2yaml.ml
index 9c76702..fff324d 100644
--- a/lib/soc2yaml.ml
+++ b/lib/soc2yaml.ml
@@ -8,13 +8,23 @@ open SocNameC
let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
- let main_soc = SocUtils.find (Lxm.dummy "dfsdf") sk stbl in
+ let main_soc = SocUtils.find (Lxm.dummy "dfsdf") sk stbl in (*recup tous les autres soc : cf socnamec*)
- let nodes = SocNameC.get_nodes main_soc in
- let filename = SocNameC.get_filename main_soc in
+ (*let nodes = SocNameC.get_nodes main_soc in*)
+ (*let socs = SocNameC.get_all_soc main_soc stbl in*)
let variables = (SocNameC.get_inputs main_soc) @ (SocNameC.get_variables main_soc) @ (SocNameC.get_outputs main_soc) in
- let instances = SocNameC.get_instances main_soc in
- let yaml_file = open_out (filename ^ ".yml") in
+ (*let instances = SocNameC.get_instances main_soc in*)
+ let tasks = SocNameC.get_tasks main_soc in
+ let yaml_file = open_out (basename ^ ".yml") in
+
+ (*let (socs2yaml : task_type -> unit) = fun soc ->
+ match soc.key with
+ | (k, _, _) -> let s = k ^ " \naeaea\n" in
+ fprintf yaml_file "%s" s
+ |_ -> let s = "XXXXX" in fprintf yaml_file
+ in
+ List.iter socs2yaml socs;*)
+
let (var2yaml : int -> string) = fun i ->
let choose_var : int -> variable_type -> bool = fun i var -> i = var.id in
@@ -26,15 +36,13 @@ let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
s
in
- (* va y avoir des tâches à la place donc penser à changer pour utiliser les instances avec des tâches
- PS : ident = la liste des ids des variables qui vont être utilisées*)
- let (tasks2yaml : instance_type -> unit) = fun inst ->
- let node = inst.node in
- let f1 : node_type -> string = fun node -> node.file_name in
- let s_vi = String.concat "" (List.map var2yaml inst.var_in) in
- let s_vo = String.concat "" (List.map var2yaml inst.var_out) in
+ (*PS : ident = la liste des ids des variables qui vont être utilisées*)
+ (*Attention : 1 tâche pour le start, 1 pour le join donc rassembler les 2 tâches*)
+ let (tasks2yaml : task_type -> unit) = fun task ->
+ let s_vi = String.concat "" (List.map var2yaml task.var_in) in
+ let s_vo = String.concat "" (List.map var2yaml task.var_out) in
let s = " - task: "
- ^ "\n name: " ^ (f1 (List.nth nodes node))
+ ^ "\n name: " ^ task.name
^ "\n var_in:\n" ^ s_vi
^ " var_out:\n" ^ s_vo
in
@@ -42,22 +50,43 @@ let (f : Soc.key -> Soc.tbl -> string -> unit) = fun sk stbl basename ->
in
let (main2yaml : unit -> unit) = fun () ->
- let s = "main_node: " ^ filename in
+ let s = "main_node: " ^ basename in
fprintf yaml_file "\n%s" s
in
fprintf yaml_file "tasks:\n";
+ (* penser a fusionner les start et join d'une tache + toujours supprimer les duplicatas APRES AVOIR FUSIONNE (sinon risque de perdre join du start)*)
let n = ref [] in
- let rec (get_one_inst_by_node : instance_type list -> instance_type list) = fun inst_list ->
- match inst_list with
+ let rec (remove_duplicate_task : task_type list -> task_type list) = fun task_list ->
+ match task_list with
|[] -> []
- |h::p -> if Bool.not (List.exists (fun v -> h.node = v) !n) then
- (n := (h.node)::!n;
- h::(get_one_inst_by_node p))
- else get_one_inst_by_node p
+ |h::p -> if Bool.not (List.exists (fun v -> h.name = v.name) !n) then
+ (n := h::!n;
+ h::(remove_duplicate_task p))
+ else remove_duplicate_task p
in
+
+ let n = ref [] in
+ let rec (fuse_start_join_task : task_type list -> task_type list) = fun task_list ->
+ match task_list with
+ |[] -> []
+ |h::p -> if Bool.not (List.exists (fun v -> h.name = v.name) !n) then (*on trouve un nouveau start*)
+ (n := h::!n;
+ h::(fuse_start_join_task p))
+ else
+ let t = List.find (fun v -> h.name = v.name) !n in
+ if (List.length t.var_out = 0) then (*on check si la tâche est pas complète (on a un start mais pas de join)*)
+ match (List.length h.var_out) with
+ |0 -> fuse_start_join_task p
+ |_ ->
+ let full_task = {name = t.name; var_in = t.var_in; var_out = h.var_out} in
+ n := full_task::!n;
+ full_task::(fuse_start_join_task p) (*Comment actualiser n pour dire qu'on a trouvé ? penser à find_index f list, mais attention ça renvoie un type option*)
+ else fuse_start_join_task p (*la tâche est déjà complète c'est juste une autre avec le même noeud on en a pas besoin*)
+ in
+
- List.iter tasks2yaml (get_one_inst_by_node instances);
+ List.iter tasks2yaml (remove_duplicate_task (List.rev (fuse_start_join_task tasks)));
main2yaml ();
diff --git a/lib/socNameC.ml b/lib/socNameC.ml
index 764c831..8298239 100644
--- a/lib/socNameC.ml
+++ b/lib/socNameC.ml
@@ -1,5 +1,7 @@
(** Time-stamp: <modified the 19/06/2024 (at 17:50) by Erwan Jahier> *)
+
+
type variable_type = {
id: int;
name: string;
@@ -20,6 +22,12 @@ type instance_type = {
var_out: int list;
}
+type task_type = {
+ name: string;
+ var_in: int list;
+ var_out: int list
+}
+
let get_filename : Soc.t -> string = fun soc ->
Soc2cIdent.get_base_name soc.key
@@ -170,33 +178,58 @@ let get_instances : Soc.t -> instance_type list = fun soc ->
(* List.iter print_instance_type res; *)
res
- let get_tasks : Soc.t -> task list = fun soc ->
- (*let gaol = get_gaol soc in*)
- let task_list = soc.tasks in
- task_list
- (*let ltbl = Hashtbl.create 2 in
- let node_cpt_ref = ref (-1) in
- let all_vars = (get_inputs_assoc soc) @ (get_outputs_assoc soc) @ (get_variables_assoc soc) in
- let gao_to_tasks i gao =
- match gao with
- | Call(_,Assign,_,_) -> assert false
- | Call(args_out, Method((_,k), _,_), args_in, _)
- | Call(args_out, Procedure (k,_) , args_in, _) ->
- let node_cpt, _inst_cpt = match Hashtbl.find_opt ltbl k with
- | None -> incr node_cpt_ref; Hashtbl.add ltbl k (!node_cpt_ref, 0); !node_cpt_ref, 0
- | Some (node_cpt, inst_cpt) ->
- let inst_cpt = inst_cpt+1 in
- Hashtbl.add ltbl k (node_cpt, inst_cpt);
- node_cpt, inst_cpt
- in
+let get_tasks : Soc.t -> task_type list = fun soc ->
+ let gaol = get_gaol soc in
+ let all_vars = (get_inputs_assoc soc) @ (get_outputs_assoc soc) @ (get_variables_assoc soc) in
+ let (gao_to_tasks: gao -> task_type option) = fun gao ->
+ match gao with
+ | Call(_,Assign,_,_) -> assert false
+ | Call(args_out, Method(_, _, task), args_in, _)
+ | Call(args_out, Procedure (_, _, task) , args_in, _) ->
+ begin
+ match task with
+ | None -> let t : task_type option = None in t
+ | Some (_, (n, _, _)) ->
+ let x = Str.split (Str.regexp "::") n in
+ let t =
{
- id = i+1;
- node = node_cpt;
+ name = List.nth x ((List.length x)-1);
var_in = List.map (var_expr_to_index all_vars) args_in;
var_out = List.map (var_expr_to_index all_vars) args_out
- }
- | Case(_, _,_) -> assert false
+ } in
+ Some t
+ end
+ | Case(_, _,_) -> assert false
+ in
+ let (to_list : task_type option -> task_type list) = fun a ->
+ match a with
+ | None -> []
+ | Some x -> [x]
+ in
+ let res = List.concat (List.map to_list (List.map gao_to_tasks gaol)) in
+ res
+
+(*faire ça : récup les socs de tous les noeuds
+let get_all_soc : Soc.t -> Soc.tbl -> Soc.t list = fun soc stbl ->
+ let gaol = get_gaol soc in
+ let rec find_soc gao = fun gao ->
+ match gao with
+ | Case(_, [(_, gaoll)], _) -> List.map find_soc gaoll
+ | Call(_, Method((_, sk), _, _), _, _)
+ | Call(_, Procedure(sk, _, _), _, _) ->
+ (SocUtils.find (Lxm.dummy "aeaea") sk stbl)
in
- let res = List.mapi gao_to_tasks gaol in
- (* List.iter print_instance_type res; *)
- res*)
+ let socs = List.map find_soc gaol in
+ let n = ref [] in
+ let rec (remove_duplicate : Soc.t list -> Soc.t list) = fun socl ->
+ match socl with
+ | [] -> []
+ | h::p -> if Bool.not (List.exists n h) then
+ (n := soc::!n;
+ h::(remove_duplicate p))
+ else
+ remove_duplicate p
+ in
+ let x = List.map remove_duplicate socs in (*supprimer les duplicatas*)
+ x*)
+
--
GitLab