From d783b03e3d8467fbe37848dfce67e3e26e5dea71 Mon Sep 17 00:00:00 2001
From: Erwan Jahier <jahier@imag.fr>
Date: Mon, 19 Jan 2015 16:14:56 +0100
Subject: [PATCH] Add a --optimize-ite/-oite option that transforms
if/then/else into merge when possible.
Indeed it is possible when each branch of the ite updates no memory.
This is done in the new L2lOptimIte module.
For the time being, it does detect when the node has no memory. It
only looks at the declaration: nodes have memory, and not functions.
I should infer that information and raise warnings or errors if what
I infer is not compatible with waht is declared (will come later).
Also split ActionsDep into ActionsDep and Action.
Also fix a bug in L2lsplit where deeply nested (>2) merge were not
splitted.
---
src/action.ml | 48 +++++++
src/action.mli | 24 ++++
src/actionsDeps.ml | 55 +-------
src/actionsDeps.mli | 36 +----
src/compile.ml | 27 ++--
src/l2lExpandNodes.ml | 26 +---
src/l2lOptimIte.ml | 202 ++++++++++++++++++++++++++++
src/l2lOptimIte.mli | 18 +++
src/l2lSplit.ml | 26 +++-
src/l2lSplit.mli | 6 +-
src/lic.ml | 2 +-
src/lic2soc.ml | 15 +--
src/lic2soc.mli | 2 +-
src/licName.ml | 26 +++-
src/licName.mli | 6 +-
src/licPrg.ml | 8 +-
src/lus2licRun.ml | 2 +-
src/lv6MainArgs.ml | 11 +-
src/lv6MainArgs.mli | 1 +
src/lv6version.ml | 4 +-
src/main.ml | 2 +-
src/sortActions.ml | 24 ++--
src/sortActions.mli | 4 +-
test/lus2lic.sum | 26 ++--
test/lus2lic.time | 16 +--
test/should_work/heater_control.lus | 2 +-
26 files changed, 442 insertions(+), 177 deletions(-)
create mode 100644 src/action.ml
create mode 100644 src/action.mli
create mode 100644 src/l2lOptimIte.ml
create mode 100644 src/l2lOptimIte.mli
diff --git a/src/action.ml b/src/action.ml
new file mode 100644
index 00000000..29dd1618
--- /dev/null
+++ b/src/action.ml
@@ -0,0 +1,48 @@
+(** Time-stamp: <modified the 15/01/2015 (at 10:45) by Erwan Jahier> *)
+
+(* exported *)
+type rhs = Soc.var_expr list
+type lhs = Soc.var_expr list
+type t = Lic.clock * rhs * lhs * Soc.atomic_operation * Lxm.t
+
+
+
+(* exported *)
+let to_string_msg: (t -> string) =
+ fun (c, i, o, p, lxm) ->
+ (* Version surchargée de Soc.string_of_operation pour afficher les "=" *)
+ let string_of_operation = function
+ | Soc.Assign -> ""
+ | op -> SocUtils.string_of_operation op
+ in
+ let string_of_params p = String.concat ", " (List.map SocUtils.string_of_filter p) in
+ if o = [] then
+ Format.sprintf "%s(%s)" (string_of_operation p) (string_of_params i)
+ else
+ Format.sprintf "%s = %s(%s) on %s"
+ (string_of_params o)
+ (string_of_operation p) (string_of_params i) (Lic.string_of_clock c)
+
+let to_string: (t -> string) =
+ fun (c, i, o, p,_) ->
+ (* Version surchargée de SocUtils.string_of_operation : l'objectif est d'afficher,
+ en cas de cycle combinatoire, un message d'erreur qui parle le plus possible
+ à l'utilisateur qui a programmé en V6... Pour cela le mieux (je pense) est
+ simplement de rendre la variable sur laquelle porte le cycle
+*)
+ let string_of_operation = function
+ | Soc.Assign -> ""
+ | Soc.Method((n, sk),sname) -> n
+ | Soc.Procedure(name,_,_) -> name
+
+ in
+ let string_of_params p = String.concat ", " (List.map SocUtils.string_of_filter p) in
+ if o = [] then
+ Format.sprintf "%s(%s)"
+ (string_of_operation p)
+ (string_of_params i)
+ else
+ Format.sprintf "%s = %s(%s)"
+ (string_of_params o)
+ (string_of_operation p)
+ (string_of_params i)
diff --git a/src/action.mli b/src/action.mli
new file mode 100644
index 00000000..7e33a238
--- /dev/null
+++ b/src/action.mli
@@ -0,0 +1,24 @@
+(** Time-stamp: <modified the 15/01/2015 (at 10:45) by Erwan Jahier> *)
+
+(** An action is an intermediary data type that is used to translate expressions
+ into [Soc.gao]. It is basically a clocked Soc.atomic_operation with arguments.
+
+ The idea is that each expression is translated into one or several actions.
+ And those clocks are then translated into guards, so that each action is
+ translated into a gao.
+
+ A more natural Module to define that type in would have been Soc, but that
+ module is meant to be shared with other front-ends (e.g., lucid-synchrone),
+ and I prefer that module not to depend on
+ - such a cutting (expr -> action -> gao)
+ - The [Eff.clock] name (could have been a module parameter though).
+ *)
+
+type rhs = Soc.var_expr list
+type lhs = Soc.var_expr list
+type t = Lic.clock * rhs * lhs * Soc.atomic_operation * Lxm.t
+
+val to_string: t -> string
+
+(* This one is meant to be used for error msgs *)
+val to_string_msg: t -> string
diff --git a/src/actionsDeps.ml b/src/actionsDeps.ml
index bad3f7d9..17720cd6 100644
--- a/src/actionsDeps.ml
+++ b/src/actionsDeps.ml
@@ -1,53 +1,8 @@
-(** Time-stamp: <modified the 06/01/2015 (at 10:52) by Erwan Jahier> *)
+(** Time-stamp: <modified the 15/01/2015 (at 10:51) by Erwan Jahier> *)
let dbg = (Verbose.get_flag "deps")
-(* exported *)
-type rhs = Soc.var_expr list
-type lhs = Soc.var_expr list
-type action = Lic.clock * rhs * lhs * Soc.atomic_operation * Lxm.t
-
-
-(*********************************************************************************)
-let string_of_action: (action -> string) =
- fun (c, i, o, p, lxm) ->
- (* Version surchargée de Soc.string_of_operation pour afficher les "=" *)
- let string_of_operation = function
- | Soc.Assign -> ""
- | op -> SocUtils.string_of_operation op
- in
- let string_of_params p = String.concat ", " (List.map SocUtils.string_of_filter p) in
- if o = [] then
- Format.sprintf "%s(%s)" (string_of_operation p) (string_of_params i)
- else
- Format.sprintf "%s = %s(%s) on %s"
- (string_of_params o)
- (string_of_operation p) (string_of_params i) (Lic.string_of_clock c)
-
-let string_of_action_simple: (action -> string) =
- fun (c, i, o, p,_) ->
- (* Version surchargée de SocUtils.string_of_operation : l'objectif est d'afficher,
- en cas de cycle combinatoire, un message d'erreur qui parle le plus possible
- à l'utilisateur qui a programmé en V6... Pour cela le mieux (je pense) est
- simplement de rendre la variable sur laquelle porte le cycle
-*)
- let string_of_operation = function
- | Soc.Assign -> ""
- | Soc.Method((n, sk),sname) -> n
- | Soc.Procedure(name,_,_) -> name
-
- in
- let string_of_params p = String.concat ", " (List.map SocUtils.string_of_filter p) in
- if o = [] then
- Format.sprintf "%s(%s)"
- (string_of_operation p)
- (string_of_params i)
- else
- Format.sprintf "%s = %s(%s)"
- (string_of_params o)
- (string_of_operation p)
- (string_of_params i)
-
+type action = Action.t
(*********************************************************************************)
module OrderedAction = struct
@@ -201,7 +156,7 @@ let rec (actions_of_vars: Soc.var_expr list -> var2actions_tbl -> action list) =
let string_of_actions: Actions.t -> string = fun s ->
let to_string a acc =
- acc ^ (string_of_action a) ^ " ; "
+ acc ^ (Action.to_string a) ^ " ; "
in
"Actions(" ^ (Actions.fold to_string s "") ^ ")"
@@ -219,7 +174,7 @@ let to_string: t -> string = fun m ->
let to_string key value acc =
let entry =
Format.sprintf "%s \n depends on \" %s \""
- (string_of_action key)
+ (Action.to_string key)
(string_of_actions value)
in
acc ^ entry ^ "\n"
@@ -255,7 +210,7 @@ let build_data_deps_from_actions: (Lic.type_ -> Data.t) -> t -> action list ->
al
in
Verbose.exe ~flag:dbg (fun () ->
- let al_str = List.map string_of_action al in
+ let al_str = List.map Action.to_string al in
print_string "\n ====> List of actions to be sorted:\n";
print_string (String.concat "\n " al_str);
print_string "\n ====> List of computed dependencies:\n";
diff --git a/src/actionsDeps.mli b/src/actionsDeps.mli
index 4e98a680..b7400dd8 100644
--- a/src/actionsDeps.mli
+++ b/src/actionsDeps.mli
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 06/10/2014 (at 10:45) by Erwan Jahier> *)
+(** Time-stamp: <modified the 15/01/2015 (at 10:43) by Erwan Jahier> *)
(** Compute dependencies between actions *)
@@ -11,30 +11,6 @@ val empty : t
val concat: t -> t -> t
-(** An action is an intermediary data type that is used to translate expressions
- into [Soc.gao]. It is basically a clocked Soc.atomic_operation with arguments.
-
- The idea is that each expression is translated into one or several actions.
- And those clocks are then translated into guards, so that each action is
- translated into a gao.
-
- A more natural Module to define that type in would have been Soc, but that
- module is meant to be shared with other front-ends (e.g., lucid-synchrone),
- and I prefer that module not to depend on
- - such a cutting (expr -> action -> gao)
- - The [Eff.clock] name (could have been a module parameter though).
- *)
-
-type rhs = Soc.var_expr list
-type lhs = Soc.var_expr list
-type action = Lic.clock * rhs * lhs * Soc.atomic_operation * Lxm.t
-
-
-
-
-val string_of_action_simple: action -> string
-
-
(** Compute the action dependencies that comes from the I/O.
Construit des dépendances entre les actions en reliant les entrées et
@@ -42,17 +18,17 @@ val string_of_action_simple: action -> string
Lic2soc.lic_to_soc_type is passed in argument to break a dep loop
*)
-val build_data_deps_from_actions: (Lic.type_ -> Data.t) -> t -> action list -> t
+val build_data_deps_from_actions: (Lic.type_ -> Data.t) -> t -> Action.t list -> t
(** Use the dependency constraints that come from the SOC (e.g., 'get' before 'set'
in memory SOC).
*)
-val generate_deps_from_step_policy: Soc.precedence list -> (string * action) list -> t
+val generate_deps_from_step_policy: Soc.precedence list -> (string * Action.t) list -> t
(** Returns the list of actions that depends on the action in argument. *)
-val find_deps: t -> action -> action list
-val have_deps : t -> action -> bool
-val remove_dep : t -> action -> t
+val find_deps: t -> Action.t -> Action.t list
+val have_deps : t -> Action.t -> bool
+val remove_dep : t -> Action.t -> t
val to_string: t -> string
diff --git a/src/compile.ml b/src/compile.ml
index f680521c..832d9dda 100644
--- a/src/compile.ml
+++ b/src/compile.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 02/10/2014 (at 11:41) by Erwan Jahier> *)
+(* Time-stamp: <modified the 16/01/2015 (at 08:58) by Erwan Jahier> *)
open Lxm
open Lv6errors
@@ -41,21 +41,28 @@ let (doit : Lv6MainArgs.t -> AstV6.pack_or_model list -> Ident.idref option -> L
in
info "Converting to lic_prg...\n";
let zelic = LicTab.to_lic_prg lic_tab in
+ let zelic =
+ if not opt.Lv6MainArgs.optim_ite then zelic else (
+ info "Optimizing if/then/else...\n";
+ L2lOptimIte.doit zelic)
+ in
+ let zelic =
(* élimination polymorphisme surcharge *)
- info "Removing polymorphism...\n";
- let zelic = L2lRmPoly.doit zelic in
+ info "Removing polymorphism...\n";
+ L2lRmPoly.doit zelic
+ in
let zelic = if not opt.Lv6MainArgs.inline_iterator then zelic else (
info "Inlining iterators...\n";
(* to be done before array expansion otherwise they won't be expanded *)
L2lExpandMetaOp.doit zelic
)
in
- let zelic =
- if
- Lv6MainArgs.global_opt.Lv6MainArgs.one_op_per_equation
+ let zelic =
+ if
+ Lv6MainArgs.global_opt.Lv6MainArgs.one_op_per_equation
|| opt.Lv6MainArgs.expand_nodes (* expand performs no fixpoint, so it will work
only if we have one op per equation...*)
- then (
+ then (
(* Split des equations (1 eq = 1 op) *)
info "One op per equations...\n";
L2lSplit.doit opt zelic)
@@ -85,7 +92,7 @@ let (doit : Lv6MainArgs.t -> AstV6.pack_or_model list -> Ident.idref option -> L
if opt.Lv6MainArgs.expand_nodes then
(if long_match_idref long mn then (long,sargs)::acc else acc)
else if
- List.exists (long_match_idref long) ids_to_expand
+ List.exists (long_match_idref long) ids_to_expand
then
acc
else
@@ -116,11 +123,11 @@ let (doit : Lv6MainArgs.t -> AstV6.pack_or_model list -> Ident.idref option -> L
info "Aliasing arrays...\n";
let zelic = L2lAliasType.doit zelic in
*)
-
(* Currently only works in this mode *)
if Lv6MainArgs.global_opt.Lv6MainArgs.ec then (
info "Check loops...\n";
- L2lCheckLoops.doit zelic);
+ L2lCheckLoops.doit zelic
+ );
info "Check unique outputs...\n";
L2lCheckOutputs.doit zelic;
info "Lic Compilation done!\n";
diff --git a/src/l2lExpandNodes.ml b/src/l2lExpandNodes.ml
index d1247ae7..1e776f40 100644
--- a/src/l2lExpandNodes.ml
+++ b/src/l2lExpandNodes.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 14/01/2015 (at 10:53) by Erwan Jahier> *)
+(* Time-stamp: <modified the 16/01/2015 (at 10:18) by Erwan Jahier> *)
open Lxm
@@ -15,25 +15,7 @@ type local_ctx = {
}
(********************************************************************************)
-
-(* stuff to create fresh var names.
- XXX code dupl. with Split.new_var
-*)
-let new_var str lctx type_eff clock_eff =
- let id = Ident.of_string (LicName.new_local_var str) in
- let var =
- {
- var_name_eff = id;
- var_nature_eff = AstCore.VarLocal;
- var_number_eff = -1; (* this field is used only for i/o.
- Should i rather put something sensible there ? *)
- var_type_eff = type_eff;
- var_clock_eff = clock_eff;
- }
- in
-(* let clk_str = string_of_clock (snd clock_eff) in *)
-(* print_string (" ===> creating "^id^ " from " ^ str^ " with clock " ^clk_str ^ "\n");flush stdout; *)
- var
+let new_var = LicName.new_var_info
(********************************************************************************)
let get_locals node =
@@ -133,7 +115,7 @@ type acc =
let (mk_fresh_loc : local_ctx -> var_info -> clock -> var_info) =
fun lctx v c ->
- new_var (Ident.to_string v.var_name_eff) lctx v.var_type_eff (fst v.var_clock_eff, c)
+ new_var (Ident.to_string v.var_name_eff) v.var_type_eff (fst v.var_clock_eff, c)
(* When expanding a node call such as
@@ -303,7 +285,7 @@ and (expand_assert : local_ctx * acc -> val_exp srcflagged -> local_ctx * acc) =
let lxm = ve.src in
let ve = ve.it in
let clk = Ident.of_string "dummy_expand_assert", BaseLic in
- let assert_var = new_var "assert" lctx Bool_type_eff clk in
+ let assert_var = new_var "assert" Bool_type_eff clk in
let assert_eq = Lxm.flagit ([LeftVarLic(assert_var,lxm)], ve) lxm in
let assert_op = Lic.VAR_REF(assert_var.var_name_eff) in
let nve = {
diff --git a/src/l2lOptimIte.ml b/src/l2lOptimIte.ml
new file mode 100644
index 00000000..e6107a7a
--- /dev/null
+++ b/src/l2lOptimIte.ml
@@ -0,0 +1,202 @@
+(** Time-stamp: <modified the 19/01/2015 (at 15:21) by Erwan Jahier> *)
+
+open Lxm
+open Lic
+open AstPredef
+
+let dbg = (Verbose.get_flag "oite")
+
+
+(********************************************************************************)
+(** The functions below accumulate
+ (1) the assertions
+ (2) the new equations
+ (3) the fresh variables
+
+*)
+
+type acc =
+ Lic.var_info list (* new local vars *)
+ * Lic.eq_info srcflagged list (* equations *)
+ * Lic.val_exp srcflagged list (* assertions *)
+
+let new_var = LicName.new_var_info
+
+(********************************************************************************)
+let (is_memory_less_val_exp : LicPrg.t -> Lic.val_exp -> bool) =
+ fun licprg ve ->
+ let rec (aux_val_exp : Lic.val_exp -> bool) =
+ fun ve -> aux_val_exp_core ve.ve_core
+ and aux_val_exp_core ve_core =
+ match ve_core with
+ | CallByPosLic(op, vel) -> (
+ (List.for_all aux_val_exp vel) && aux_pos_op op.it
+ )
+ | CallByNameLic(_,cl) -> (
+ let vel = (snd (List.split cl)) in
+ List.for_all aux_val_exp vel
+ )
+ | Merge(ve,cl) -> (
+ let vel = ve::(snd (List.split cl)) in
+ List.for_all aux_val_exp vel
+ )
+ and (aux_pos_op: Lic.by_pos_op -> bool) =
+ function
+ | CALL({it=nk}) | PREDEF_CALL({it=nk}) -> (
+ match LicPrg.find_node licprg nk with
+ | None -> assert false (* SNO *)
+ | Some node_exp -> not node_exp.has_mem_eff
+ )
+ | CURRENT _ (* XXX not clear. false is the safe value anyway. *)
+ | PRE | ARROW | FBY -> false
+
+ | WHEN _
+ | TUPLE
+ | CONCAT | HAT (_) | ARRAY| ARRAY_SLICE(_) | ARRAY_ACCES(_) | STRUCT_ACCESS(_)
+ | CONST _ | CONST_REF _ | VAR_REF _ -> true
+ in
+ aux_val_exp ve
+
+let (clock_of_cond: val_exp -> bool -> acc -> clock list * acc) =
+ fun ve b acc ->
+ let ve_clk = match ve.ve_clk with [clk] -> clk | _ -> assert false in
+ let b = if b then "true" else "false" in
+ let cc = "Lustre", b in
+ let lxm = Lic.lxm_of_val_exp ve in
+ let cv,acc = match ve with
+ | { ve_core= CallByPosLic({it=VAR_REF id},[]) } -> id,acc
+ | _ ->
+ let nv = new_var "clk__of_ite" Bool_type_eff ("dummy",ve_clk) in
+ let eq = {src=lxm;it=[LeftVarLic (nv, lxm)], ve} in
+ let v,eqs,ass = acc in
+ let acc = nv::v,eq::eqs,ass in
+ nv.var_name_eff, acc
+ in
+ [On((cc,cv,Bool_type_eff), List.hd ve.ve_clk)], acc
+
+let (gen_merge : Lxm.t -> Lic.val_exp -> Lic.val_exp -> Lic.val_exp -> acc ->
+ Lic.val_exp_core * acc ) =
+ fun lxm cond ve1 ve2 acc ->
+ (* this is the core of the module *)
+ let true_cst = { it=Bool_const_eff true ; src = lxm } in
+ let false_cst = { it=Bool_const_eff false; src = lxm } in
+ let clk_true,acc = clock_of_cond cond true acc in
+ let clk_false,acc = clock_of_cond cond false acc in
+ let case_true = true_cst, { ve1 with ve_clk = clk_true } in
+ let case_false = false_cst, { ve2 with ve_clk = clk_false } in
+ Merge(cond, [case_true; case_false]), acc
+
+
+(* All the remaining are admnistrative functions *)
+
+let rec (do_eq : LicPrg.t -> Lic.eq_info srcflagged -> acc -> acc) =
+ fun licprg { src = lxm_eq ; it = (left_list, ve) } acc ->
+ let ve, (nv,neqs,nass) = do_val_exp licprg ve acc in
+ nv, { src = lxm_eq ; it = (left_list, ve) }::neqs, nass
+
+and (do_val_exp: LicPrg.t -> val_exp -> acc -> val_exp * acc) =
+ fun licprg ve acc ->
+ let ve_core, acc =
+ match ve.ve_core with
+ | Merge(ce,cl) -> (
+ let cl,acc =
+ List.fold_left
+ (fun (ncl,acc) (c, ve) ->
+ let ve, acc = do_val_exp licprg ve acc in
+ ((c, ve)::ncl), acc
+ )
+ ([],acc)
+ cl
+ in
+ Merge(ce,cl),acc
+ )
+ | CallByNameLic(op, fl) -> (
+ let fl,acc = List.fold_left
+ (fun (nfl,acc) (id,ve) ->
+ let nf, acc = do_val_exp licprg ve acc in
+ ((id,nf)::nfl), acc
+ )
+ ([],acc)
+ fl
+ in
+ CallByNameLic(op, fl), acc
+ )
+ | CallByPosLic (op, vel) -> (
+ let vel, acc = List.fold_left
+ (fun (vel,acc) ve ->
+ let ve, acc = do_val_exp licprg ve acc in
+ (ve::vel), acc
+ )
+ ([],acc)
+ (List.rev vel)
+ in
+ match op.it with
+ | PREDEF_CALL({src=if_lxm; it=("Lustre","if"),[]}) -> (
+ match vel with
+ | [cond; ve1; ve2] ->
+ if is_memory_less_val_exp licprg ve1 &&
+ is_memory_less_val_exp licprg ve2
+ then
+ gen_merge op.src cond ve1 ve2 acc
+ else
+ CallByPosLic(op, vel), acc
+ | _ -> assert false (* SNO *)
+ )
+ | _ -> CallByPosLic(op, vel), acc
+ )
+ in
+ { ve with ve_core = ve_core },acc
+
+and (do_val_exp_flag: LicPrg.t -> val_exp srcflagged -> acc -> val_exp srcflagged * acc) =
+ fun licprg ve_f acc ->
+ let ve, acc = do_val_exp licprg ve_f.it acc in
+ { ve_f with it = ve }, acc
+
+and (do_node : LicPrg.t -> Lic.node_exp -> Lic.node_exp) =
+ fun licprg n ->
+ match n.def_eff with
+ | ExternLic | MetaOpLic | AbstractLic _ -> n
+ | BodyLic b ->
+ let acc = List.fold_left
+ (fun acc eq -> do_eq licprg eq acc)
+ ([],[],[])
+ (List.rev b.eqs_eff)
+ in
+ let acc = List.fold_left
+ (fun acc ve ->
+ let ve,(nv,neq,nass) = do_val_exp_flag licprg ve acc in
+ (nv,neq,ve::nass)
+ )
+ acc
+ b.asserts_eff
+ in
+ let (nv,neqs,nass) = acc in
+ let nlocs = match n.loclist_eff with
+ | None -> nv (* SNO, but eats no bread *)
+ | Some v -> List.rev_append nv v
+ in
+ { n with
+ def_eff = BodyLic {
+ eqs_eff = neqs;
+ asserts_eff = nass;
+ };
+ loclist_eff = Some nlocs;
+ }
+
+(* exported *)
+let rec (doit : LicPrg.t -> LicPrg.t) =
+ fun inprg ->
+ let outprg = LicPrg.empty in
+ (** types and constants do not change *)
+ let outprg = LicPrg.fold_types LicPrg.add_type inprg outprg in
+ let outprg = LicPrg.fold_consts LicPrg.add_const inprg outprg in
+ (** transform nodes *)
+ let rec (doit_node : Lic.node_key -> Lic.node_exp -> LicPrg.t -> LicPrg.t) =
+ fun nk ne outprg ->
+ Verbose.exe ~flag:dbg (fun() -> Printf.printf "#DBG: L2lOptimIte '%s'\n"
+ (Lic.string_of_node_key nk));
+ let ne = do_node inprg ne in
+ LicPrg.add_node nk ne outprg
+ in
+ let outprg = LicPrg.fold_nodes doit_node inprg outprg in
+ outprg
diff --git a/src/l2lOptimIte.mli b/src/l2lOptimIte.mli
new file mode 100644
index 00000000..2b7749b3
--- /dev/null
+++ b/src/l2lOptimIte.mli
@@ -0,0 +1,18 @@
+(* Time-stamp: <modified the 14/01/2015 (at 17:31) by Erwan Jahier> *)
+
+
+(** Transforms expressions of the form
+
+ if c then n(...) else m(...)
+
+ into
+
+ merge c (true -> n(...) when c) (false -> m(...) when not(c))
+
+ Of course, this is done iff neither n nor m uses memories.
+
+*)
+
+val doit : LicPrg.t -> LicPrg.t
+
+
diff --git a/src/l2lSplit.ml b/src/l2lSplit.ml
index e15de8dc..0df56ea1 100644
--- a/src/l2lSplit.ml
+++ b/src/l2lSplit.ml
@@ -16,6 +16,9 @@ let info msg =
Verbose.exe ~flag:dbg (fun () -> Printf.eprintf "%4.4f: %s%!" t msg)
(********************************************************************************)
+
+(* XXX use LicName.new_var_info *)
+
let new_var getid type_eff clock_eff =
let id = getid "v" in
let var =
@@ -187,13 +190,30 @@ and (split_val_exp : bool -> bool -> LicPrg.id_generator -> Lic.val_exp ->
is no "when"...
*)
match ve.ve_core with
- | Merge(ce,cl) ->
+ | Merge(ce,cl) -> (
let ce,(eql1, vl1) = split_val_exp false false getid ce in
let const_l, vel = List.split cl in
let vel,(eql2, vl2) = split_val_exp_list false false getid vel in
+ let eql, vl = eql1@eql2, vl1@vl2 in
let cl = List.combine const_l vel in
- { ve with ve_core = Merge(ce,cl)}, (eql1@eql2, vl1@vl2)
-
+ let rhs = { ve with ve_core = Merge(ce,cl)} in
+ if top_level then rhs, (eql, vl) else
+ (* create the var for the current call *)
+ let clk_l = ve.ve_clk in
+ let typ_l = ve.ve_typ in
+ assert (List.length typ_l = List.length clk_l);
+ let nv_l = List.map2 (new_var getid) typ_l clk_l in
+ let lxm = lxm_of_val_exp ve in
+ let nve = match nv_l with
+ | [nv] -> { ve with ve_core =
+ CallByPosLic(
+ Lxm.flagit (Lic.VAR_REF (nv.var_name_eff)) lxm, [])}
+ | _ -> assert false
+ in
+ let lpl = List.map (fun nv -> LeftVarLic(nv, lxm)) nv_l in
+ let eq = Lxm.flagit (lpl, rhs) lxm in
+ nve, (eql@[eq], vl@nv_l)
+ )
| CallByPosLic({it=Lic.VAR_REF _}, _) -> ve, ([],[])
| CallByPosLic({it=Lic.CONST_REF _}, _) -> ve, ([],[])
| CallByPosLic({src=lxm;it=Lic.CONST _}, _)
diff --git a/src/l2lSplit.mli b/src/l2lSplit.mli
index a5b8d5c5..43b4a73f 100644
--- a/src/l2lSplit.mli
+++ b/src/l2lSplit.mli
@@ -1,12 +1,8 @@
-(* Time-stamp: <modified the 04/09/2014 (at 10:41) by Erwan Jahier> *)
+(* Time-stamp: <modified the 16/01/2015 (at 10:08) by Erwan Jahier> *)
(** Split the equations of a node into several ones, in such a way
that there is only one operator per equation.
-
- The rationale for doing that is to make the clock checking
- trivial in the lic code (indeed, nested node call makes it
- tricky).
We also split tuples. For example, the equation:
diff --git a/src/lic.ml b/src/lic.ml
index d240bd84..b5cc04de 100644
--- a/src/lic.ml
+++ b/src/lic.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 07/01/2015 (at 08:47) by Erwan Jahier> *)
+(* Time-stamp: <modified the 16/01/2015 (at 14:50) by Erwan Jahier> *)
(** Define the Data Structure representing Compiled programs. By
compiled we mean that constant are propagated, packages are
diff --git a/src/lic2soc.ml b/src/lic2soc.ml
index fc329dba..6051eddf 100644
--- a/src/lic2soc.ml
+++ b/src/lic2soc.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 12/01/2015 (at 14:10) by Erwan Jahier> *)
+(** Time-stamp: <modified the 19/01/2015 (at 14:13) by Erwan Jahier> *)
(* XXX ce module est mal écrit. A reprendre. (R1) *)
@@ -7,7 +7,7 @@ open Lic
let dbg = (Verbose.get_flag "exec")
-type action = ActionsDeps.action
+type action = Action.t
(* Raised when a soc that haven't been translated yet is used in
another soc during the translation *)
@@ -293,14 +293,14 @@ let (soc_key_of_node_exp : Lic.node_exp -> Soc.key) =
let (id,tl,key_opt) = make_soc_key_of_node_key n.node_key_eff None (List.map snd (svi@svo)) in
(id,tl,key_opt)
-(* Translate val_exp into left parts. XXX duplicated code with get_leaf *)
+(* Translate val_exp into wires. XXX duplicated code with get_leaf *)
let rec (val_exp_to_filter: LicPrg.t -> Lic.val_exp -> Soc.var_expr list) =
fun licprg val_exp ->
let v = val_exp.Lic.ve_core in
let type_ = val_exp.Lic.ve_typ in
match v with
- | CallByNameLic(by_name_op_flg,fl) -> assert false (* should not occur *)
- | Merge(c_flg, cl) -> assert false (* should not occur *)
+ | CallByNameLic(by_name_op_flg,fl) -> assert false (* SNO if correctly L2lSpitted *)
+ | Merge(c_flg, cl) -> assert false (* Should Not Occur if correctly L2lSpitted *)
| CallByPosLic (by_pos_op_flg, val_exp_list) -> (
match by_pos_op_flg.it with
| WHEN(e) -> (* ignore it. A good idea ? Such when should only appear for const *)
@@ -379,8 +379,7 @@ let rec (is_a_sub_clock : Lic.clock -> Lic.clock -> bool) =
| On(_,ck1), On(_,_) -> ck1 = ck2 || is_a_sub_clock ck1 ck2
| ClockVar _, _ -> assert false
| _, ClockVar _ -> assert false
- | _, _ -> assert false
-
+
(* We can have 2 different definitions for the clock of an
expression. It can be the clock of its output, which is useful to
@@ -686,7 +685,7 @@ and (actions_of_expression : Lxm.t -> Soc.tbl -> ctx -> Lic.clock -> Soc.var_exp
(*********************************************************************************)
-(** Translates a equation into one or several actions.
+(** Translates an equation into one or several actions.
Generated dependencies are merged by the caller.
*)
diff --git a/src/lic2soc.mli b/src/lic2soc.mli
index 37244fad..730bc939 100644
--- a/src/lic2soc.mli
+++ b/src/lic2soc.mli
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 02/10/2014 (at 17:42) by Erwan Jahier> *)
+(** Time-stamp: <modified the 15/01/2015 (at 13:38) by Erwan Jahier> *)
val f: LicPrg.t -> Lic.node_key -> Soc.key * Soc.tbl
diff --git a/src/licName.ml b/src/licName.ml
index 321199b7..887a6412 100644
--- a/src/licName.ml
+++ b/src/licName.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 11/04/2013 (at 15:47) by Erwan Jahier> *)
+(* Time-stamp: <modified the 16/01/2015 (at 13:53) by Erwan Jahier> *)
(* maps node_key to a string that won't clash *)
@@ -119,7 +119,11 @@ let (update_fresh_var_prefix : unit -> unit) =
)
(********************************************************************************)
-(* exported *)
+(* exported
+
+XXX duplique le job de LicPrg.id_generator !!!
+*)
+
let (new_local_var : string -> string) =
fun prefix ->
try
@@ -131,6 +135,24 @@ let (new_local_var : string -> string) =
Hashtbl.add local_var_tbl prefix 2;
!fresh_var_prefix ^ prefix ^ "_1"
+(********************************************************************************)
+(* exported *)
+open Lic
+let (new_var_info : string -> Lic.type_ -> Lic.id_clock -> Lic.var_info) =
+ fun str type_eff clock_eff ->
+ let id = Ident.of_string (new_local_var str) in
+ let var =
+ {
+ var_name_eff = id;
+ var_nature_eff = AstCore.VarLocal;
+ var_number_eff = -1; (* this field is used only for i/o.
+ Should i rather put something sensible there ? *)
+ var_type_eff = type_eff;
+ var_clock_eff = clock_eff;
+ }
+ in
+ var
+
(********************************************************************************)
diff --git a/src/licName.mli b/src/licName.mli
index 41433364..818748bc 100644
--- a/src/licName.mli
+++ b/src/licName.mli
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 16/01/2013 (at 17:52) by Erwan Jahier> *)
+(* Time-stamp: <modified the 16/01/2015 (at 13:52) by Erwan Jahier> *)
(** All new identifier names ougth to be created via this module. *)
@@ -21,9 +21,13 @@ val node_key: Lic.node_key -> string -> string
val new_local_var : string -> string (* mv new_var? *)
+(** Returns a fresh local var_info *)
+val new_var_info : string -> Lic.type_ -> Lic.id_clock -> Lic.var_info
+
(** *)
val array_type : Lic.type_ -> string -> string
(** To be called just after the parsing (to make sure that fresh var names won't clash with
user idents. ) *)
val update_fresh_var_prefix : unit -> unit
+
diff --git a/src/licPrg.ml b/src/licPrg.ml
index 745ce883..f555c63d 100644
--- a/src/licPrg.ml
+++ b/src/licPrg.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 09/10/2014 (at 09:56) by Erwan Jahier> *)
+(* Time-stamp: <modified the 16/01/2015 (at 10:24) by Erwan Jahier> *)
module ItemKeyMap = struct
include Map.Make (
@@ -265,7 +265,11 @@ let to_file (opt: Lv6MainArgs.t) (this:t) (main_node: Ident.idref option) =
this.nodes
)
-(* GENERATEUR DE NOM DE VARIABLES *)
+(* GENERATEUR DE NOM DE VARIABLES
+
+XXX Refait le boulot de LicName !!! Merger les 2 mechanismes et prendre le meilleur !!!
+ce qui est sur, c'est qu'il est mal rangé ici !!!
+*)
type id_generator = string -> string
let fresh_var_id_generator : t -> Lic.node_exp -> id_generator =
diff --git a/src/lus2licRun.ml b/src/lus2licRun.ml
index eef62bfd..1e86423d 100644
--- a/src/lus2licRun.ml
+++ b/src/lus2licRun.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 14/08/2014 (at 16:45) by Erwan Jahier> *)
+(* Time-stamp: <modified the 15/01/2015 (at 13:43) by Erwan Jahier> *)
(*-----------------------------------------------------------------------
** Copyright (C) - Verimag.
*)
diff --git a/src/lv6MainArgs.ml b/src/lv6MainArgs.ml
index c9afc552..01029b1a 100644
--- a/src/lv6MainArgs.ml
+++ b/src/lv6MainArgs.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 09/10/2014 (at 16:37) by Erwan Jahier> *)
+(* Time-stamp: <modified the 19/01/2015 (at 14:22) by Erwan Jahier> *)
(*
Le manager d'argument adapté de celui de lutin, plus joli
N.B. solution un peu batarde : les options sont stockées, comme avant, dans Global,
@@ -29,6 +29,7 @@ type t = {
mutable expand_nodes : bool;
mutable expand_node_call : string list;
mutable expand_arrays : bool;
+ mutable optim_ite : bool;
mutable gen_autotest : bool;
mutable oc : Pervasives.out_channel;
mutable tlex : bool;
@@ -89,6 +90,7 @@ let (make_opt : unit -> t) =
expand_nodes = false;
expand_node_call = [];
expand_arrays = false;
+ optim_ite = false;
gen_autotest = false;
(** the output channel *)
oc = Pervasives.stdout;
@@ -251,7 +253,7 @@ let mkoptab (opt:t) : unit = (
["-knc"; "--keep-nested-calls"]
(Arg.Unit (fun _ -> global_opt.one_op_per_equation <- false))
["Keep nested calls (inhibited by -en). By default, only one node ";
- "per equation is generated."]
+ "per equation is generated (don't work with -exec or -2c)."]
;
mkopt opt
["-ei"; "--expand-iterators"]
@@ -288,6 +290,11 @@ let mkoptab (opt:t) : unit = (
))
["Expand the call of the specified node (can be used for several nodes)."]
;
+ mkopt opt
+ ["-oite"; "--optimize-ite"]
+ (Arg.Unit (fun _ -> opt.optim_ite <- true))
+ ["Transform if/then/else into merge when possible."]
+ ;
mkopt opt
["-lv4"; "--lustre-v4"]
(Arg.Unit (fun _ -> set_v4_options opt))
diff --git a/src/lv6MainArgs.mli b/src/lv6MainArgs.mli
index 4dc824c9..3da308ad 100644
--- a/src/lv6MainArgs.mli
+++ b/src/lv6MainArgs.mli
@@ -27,6 +27,7 @@ type t = {
mutable expand_nodes : bool;
mutable expand_node_call : string list;
mutable expand_arrays : bool;
+ mutable optim_ite : bool;
mutable gen_autotest : bool;
mutable oc : Pervasives.out_channel;
mutable tlex : bool;
diff --git a/src/lv6version.ml b/src/lv6version.ml
index 3c52b7b2..d361ce2c 100644
--- a/src/lv6version.ml
+++ b/src/lv6version.ml
@@ -1,7 +1,7 @@
(** Automatically generated from Makefile *)
let tool = "lus2lic"
let branch = "master"
-let commit = "546"
-let sha_1 = "fcf73b924af20970d8124c8858817763ca3e1f1f"
+let commit = "547"
+let sha_1 = "79e85ff20f718dd61a30e2425983bd9aadc4424f"
let str = (branch ^ "." ^ commit ^ " (" ^ sha_1 ^ ")")
let maintainer = "jahier@imag.fr"
diff --git a/src/main.ml b/src/main.ml
index 374c284c..a0066e62 100644
--- a/src/main.ml
+++ b/src/main.ml
@@ -1,4 +1,4 @@
-(* Time-stamp: <modified the 04/09/2014 (at 11:39) by Erwan Jahier> *)
+(* Time-stamp: <modified the 15/01/2015 (at 13:43) by Erwan Jahier> *)
open Verbose
open AstV6
diff --git a/src/sortActions.ml b/src/sortActions.ml
index dc913241..370dc0fc 100644
--- a/src/sortActions.ml
+++ b/src/sortActions.ml
@@ -1,4 +1,4 @@
-(** Time-stamp: <modified the 06/01/2015 (at 17:46) by Erwan Jahier> *)
+(** Time-stamp: <modified the 15/01/2015 (at 10:52) by Erwan Jahier> *)
(** topological sort of actions (that may optimize test openning) *)
@@ -6,7 +6,7 @@ open ActionsDeps
(*********************************************************************************)
module OrderedAction = struct
- type t = ActionsDeps.action
+ type t = Action.t
let compare = compare
end
module MapAction = Map.Make(OrderedAction)
@@ -15,15 +15,15 @@ module MapAction = Map.Make(OrderedAction)
type color = Grey | Black (* in process | done *)
type color_table = color MapAction.t
-exception DependencyCycle of action * action list
+exception DependencyCycle of Action.t * Action.t list
(* exception DependencyCycle of Soc.var_expr list *)
-let (grey_actions : color_table -> ActionsDeps.action list) =
+let (grey_actions : color_table -> Action.t list) =
fun ct ->
MapAction.fold
(fun action color acc -> if color=Grey then action::acc else acc) ct []
-let rec (visit : ActionsDeps.t -> color_table -> ActionsDeps.action -> color_table) =
+let rec (visit : ActionsDeps.t -> color_table -> Action.t -> color_table) =
fun succ_t color_t n ->
if not (ActionsDeps.have_deps succ_t n) then MapAction.add n Black color_t else
let color_t =
@@ -43,17 +43,17 @@ let rec (visit : ActionsDeps.t -> color_table -> ActionsDeps.action -> color_tab
MapAction.add n Black color_t
(* TEDLT *)
-let (check_there_is_no_cycle : ActionsDeps.action list -> ActionsDeps.t -> unit) =
+let (check_there_is_no_cycle : Action.t list -> ActionsDeps.t -> unit) =
fun actions t ->
List.iter (fun action -> ignore(visit t MapAction.empty action)) actions
-let (topo_sort : ActionsDeps.action list -> ActionsDeps.t -> ActionsDeps.action list) =
+let (topo_sort : Action.t list -> ActionsDeps.t -> Action.t list) =
fun actions stbl ->
let visited_init =
List.fold_left (fun acc x -> MapAction.add x false acc) MapAction.empty actions
in
- let rec f (acc:action list) (l:action list) (stbl:t) (visited:bool MapAction.t) =
+ let rec f (acc:Action.t list) (l:Action.t list) (stbl:t) (visited:bool MapAction.t) =
(* The graph contains no cycle! *)
match l with
| [] -> List.rev acc
@@ -74,7 +74,7 @@ let (topo_sort : ActionsDeps.action list -> ActionsDeps.t -> ActionsDeps.action
(*********************************************************************************)
(* From actions to gaos *)
-let rec (gao_of_action: action -> Soc.gao) =
+let rec (gao_of_action: Action.t -> Soc.gao) =
fun (ck, il, ol, op, _lxm) ->
let rec unpack_clock = function
| Lic.BaseLic -> Soc.Call (ol, op, il)
@@ -125,14 +125,14 @@ let (optimize_test_openning: Soc.gao list -> ActionsDeps.t -> Soc.gao list) =
(*********************************************************************************)
-let (f : action list -> ActionsDeps.t -> Lxm.t -> Soc.gao list) =
+let (f : Action.t list -> ActionsDeps.t -> Lxm.t -> Soc.gao list) =
fun actions deps lxm ->
let actions =
try topo_sort actions deps
with DependencyCycle(x,l) ->
- let l = List.map ActionsDeps.string_of_action_simple l in
+ let l = List.map Action.to_string l in
let msg = "A combinational cycle been detected "^
- (Lxm.details lxm)^" on \n "^(ActionsDeps.string_of_action_simple x)^
+ (Lxm.details lxm)^" on \n "^(Action.to_string x)^
"\n "^(String.concat "\n " l) ^ "\n\nHint: try to use --expand-nodes.\n"
in
raise (Lv6errors.Global_error msg)
diff --git a/src/sortActions.mli b/src/sortActions.mli
index 020ca92f..48163f07 100644
--- a/src/sortActions.mli
+++ b/src/sortActions.mli
@@ -1,8 +1,8 @@
-(** Time-stamp: <modified the 16/11/2014 (at 21:37) by Erwan JAHIER> *)
+(** Time-stamp: <modified the 15/01/2015 (at 10:47) by Erwan Jahier> *)
(** Topological sort of actions. Raises an error in a Dependency Cycle
is found (hence the Lxm.t). *)
-val f : ActionsDeps.action list -> ActionsDeps.t -> Lxm.t -> Soc.gao list
+val f : Action.t list -> ActionsDeps.t -> Lxm.t -> Soc.gao list
diff --git a/test/lus2lic.sum b/test/lus2lic.sum
index 8a3e08e0..d0adb9de 100644
--- a/test/lus2lic.sum
+++ b/test/lus2lic.sum
@@ -1,5 +1,5 @@
==> lus2lic0.sum <==
-Test Run By jahier on Wed Jan 14 15:45:00
+Test Run By jahier on Mon Jan 19 16:04:58
Native configuration is x86_64-unknown-linux-gnu
=== lus2lic0 tests ===
@@ -63,7 +63,7 @@ XFAIL: Test bad programs (assert): test_lus2lic_no_node should_fail/assert/lecte
XFAIL: Test bad programs (assert): test_lus2lic_no_node should_fail/assert/s.lus
==> lus2lic1.sum <==
-Test Run By jahier on Wed Jan 14 15:45:02
+Test Run By jahier on Mon Jan 19 16:05:02
Native configuration is x86_64-unknown-linux-gnu
=== lus2lic1 tests ===
@@ -397,7 +397,7 @@ PASS: gcc -o multipar.exec multipar_multipar.c multipar_multipar_loop.c
PASS: /home/jahier/lus2lic/test/../utils/compare_exec_and_2c multipar.lus {}
==> lus2lic2.sum <==
-Test Run By jahier on Wed Jan 14 15:44:57
+Test Run By jahier on Mon Jan 19 16:05:04
Native configuration is x86_64-unknown-linux-gnu
=== lus2lic2 tests ===
@@ -727,7 +727,7 @@ PASS: gcc -o zzz2.exec zzz2_zzz2.c zzz2_zzz2_loop.c
PASS: /home/jahier/lus2lic/test/../utils/compare_exec_and_2c zzz2.lus {}
==> lus2lic3.sum <==
-Test Run By jahier on Wed Jan 14 15:45:06
+Test Run By jahier on Mon Jan 19 16:05:00
Native configuration is x86_64-unknown-linux-gnu
=== lus2lic3 tests ===
@@ -1230,7 +1230,7 @@ PASS: ./myec2c {-o multipar.c multipar.ec}
PASS: /home/jahier/lus2lic/test/../utils/test_lus2lic_no_node multipar.lus {}
==> lus2lic4.sum <==
-Test Run By jahier on Wed Jan 14 15:45:04
+Test Run By jahier on Mon Jan 19 16:05:06
Native configuration is x86_64-unknown-linux-gnu
=== lus2lic4 tests ===
@@ -1727,13 +1727,13 @@ PASS: /home/jahier/lus2lic/test/../utils/test_lus2lic_no_node zzz2.lus {}
===============================
# Total number of failures: 14
lus2lic0.log:testcase ./lus2lic.tests/test0.exp completed in 6 seconds
-lus2lic1.log:testcase ./lus2lic.tests/test1.exp completed in 59 seconds
-lus2lic2.log:testcase ./lus2lic.tests/test2.exp completed in 79 seconds
-lus2lic3.log:testcase ./lus2lic.tests/test3.exp completed in 51 seconds
-lus2lic4.log:testcase ./lus2lic.tests/test4.exp completed in 84 seconds
+lus2lic1.log:testcase ./lus2lic.tests/test1.exp completed in 48 seconds
+lus2lic2.log:testcase ./lus2lic.tests/test2.exp completed in 74 seconds
+lus2lic3.log:testcase ./lus2lic.tests/test3.exp completed in 48 seconds
+lus2lic4.log:testcase ./lus2lic.tests/test4.exp completed in 82 seconds
* Ref time:
-0.04user 0.10system 4:01.57elapsed 0%CPU (0avgtext+0avgdata 3012maxresident)k
-0inputs+0outputs (0major+14885minor)pagefaults 0swaps
+0.04user 0.10system 4:11.13elapsed 0%CPU (0avgtext+0avgdata 3016maxresident)k
+0inputs+0outputs (0major+14906minor)pagefaults 0swaps
* Quick time (-j 4):
-0.05user 0.06system 1:30.66elapsed 0%CPU (0avgtext+0avgdata 3012maxresident)k
-0inputs+0outputs (0major+14899minor)pagefaults 0swaps
+0.06user 0.08system 1:30.70elapsed 0%CPU (0avgtext+0avgdata 3016maxresident)k
+0inputs+0outputs (0major+14923minor)pagefaults 0swaps
diff --git a/test/lus2lic.time b/test/lus2lic.time
index ee36a3a9..a84daae2 100644
--- a/test/lus2lic.time
+++ b/test/lus2lic.time
@@ -1,11 +1,11 @@
lus2lic0.log:testcase ./lus2lic.tests/test0.exp completed in 6 seconds
-lus2lic1.log:testcase ./lus2lic.tests/test1.exp completed in 59 seconds
-lus2lic2.log:testcase ./lus2lic.tests/test2.exp completed in 79 seconds
-lus2lic3.log:testcase ./lus2lic.tests/test3.exp completed in 51 seconds
-lus2lic4.log:testcase ./lus2lic.tests/test4.exp completed in 84 seconds
+lus2lic1.log:testcase ./lus2lic.tests/test1.exp completed in 48 seconds
+lus2lic2.log:testcase ./lus2lic.tests/test2.exp completed in 74 seconds
+lus2lic3.log:testcase ./lus2lic.tests/test3.exp completed in 48 seconds
+lus2lic4.log:testcase ./lus2lic.tests/test4.exp completed in 82 seconds
* Ref time:
-0.04user 0.10system 4:01.57elapsed 0%CPU (0avgtext+0avgdata 3012maxresident)k
-0inputs+0outputs (0major+14885minor)pagefaults 0swaps
+0.04user 0.10system 4:11.13elapsed 0%CPU (0avgtext+0avgdata 3016maxresident)k
+0inputs+0outputs (0major+14906minor)pagefaults 0swaps
* Quick time (-j 4):
-0.05user 0.06system 1:30.66elapsed 0%CPU (0avgtext+0avgdata 3012maxresident)k
-0inputs+0outputs (0major+14899minor)pagefaults 0swaps
+0.06user 0.08system 1:30.70elapsed 0%CPU (0avgtext+0avgdata 3016maxresident)k
+0inputs+0outputs (0major+14923minor)pagefaults 0swaps
diff --git a/test/should_work/heater_control.lus b/test/should_work/heater_control.lus
index 02937bde..5d0db95f 100644
--- a/test/should_work/heater_control.lus
+++ b/test/should_work/heater_control.lus
@@ -42,7 +42,7 @@ let
Tguess =
if noneoftree(V12, V13, V23) then FAILURE else
if oneoftree(V12, V13, V23) then Median(T1, T2, T3) else
- if alloftree(V12, V13, V23) then Median(T1, T2, T3) else
+ if alloftree(V12, V13, V23) then Median(T1, T2, T3) else
-- 2 among V1, V2, V3 are false
if V12 then Average(T1, T2) else
if V13 then Average(T1, T3) else
--
GitLab