[m-rev.] diff: speed up compilation of large predicates
Zoltan Somogyi
zs at cs.mu.OZ.AU
Wed Sep 28 14:29:08 AEST 2005
Speed up the compilation of predicates with lots of disjuncts dramatically.
With this change, the time to compile the transitive closure tabling benchmark
with an 8000 clause "edge" predicate falls from 230 seconds to 14, a 94%
reduction. The time to compile the six largest compiler modules is unaffected.
Previously, I added the mode_check_clauses pragma to accomplish a similar
reduction in compilation time for such predicates. (Actually, that pragma
gets an even bigger speedup, since a fast merging of instmaps still takes
more time than not merging instmaps at all.) However, this solution is better,
since the user doesn't have to remember to use a pragma, it works even on
if-then-elses and non-outermost disjunctions, and it avoids losing the
information that mode_check_clauses loses about the final insts of the
affected variables.
compiler/instmap.m:
Replace the old algorithms for merging the insts of a variable at the
ends of the arms of branched control structures, whose complexity was
N^2, with algorithms whose complexity is N log N.
compiler/mode_util.m:
Instead of writing explicit N^2 code to merge the insts of variables
at the ends of the arms of branched control structures when recomputing
instmap_deltas, call the new N log N algorithm in instmap.m.
compiler/inst_util.m:
Fix incorrect documentation, and delete redundant documentation.
compiler/modes.m:
Minor style fixes.
Zoltan.
cvs diff: Diffing .
cvs diff: Diffing analysis
cvs diff: Diffing bindist
cvs diff: Diffing boehm_gc
cvs diff: Diffing boehm_gc/Mac_files
cvs diff: Diffing boehm_gc/cord
cvs diff: Diffing boehm_gc/cord/private
cvs diff: Diffing boehm_gc/doc
cvs diff: Diffing boehm_gc/include
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing boehm_gc/tests
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/inst_util.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/inst_util.m,v
retrieving revision 1.38
diff -u -b -r1.38 inst_util.m
--- compiler/inst_util.m 27 Aug 2005 09:41:55 -0000 1.38
+++ compiler/inst_util.m 27 Sep 2005 12:23:58 -0000
@@ -86,7 +86,7 @@
%-----------------------------------------------------------------------------%
- % inst_merge(InstA, InstB, InstC):
+ % inst_merge(InstA, InstB, MaybeType, InstC, !ModuleInfo):
%
% Combine the insts found in different arms of a disjunction (or
% if-then-else). The information in InstC is the minimum of the information
@@ -1319,13 +1319,6 @@
%-----------------------------------------------------------------------------%
- % inst_merge(InstA, InstB, InstC):
- %
- % Combine the insts found in different arms of a disjunction (or
- % if-then-else). The information in InstC is the minimum of the information
- % in InstA and InstB. Where InstA and InstB specify a binding (free
- % or bound), it must be the same in both.
- %
inst_merge(InstA, InstB, MaybeType, Inst, !ModuleInfo) :-
% Check whether this pair of insts is already in the merge_insts table.
module_info_insts(!.ModuleInfo, InstTable0),
@@ -1480,9 +1473,8 @@
; pred_inst_matches(PredB, PredA, !.ModuleInfo) ->
GroundInstInfo = higher_order(PredA)
;
- % If either is a function inst with non-standard
- % modes, don't allow the higher-order
- % information to be lost.
+ % If either is a function inst with non-standard modes,
+ % don't allow the higher-order information to be lost.
\+ pred_inst_info_is_nonstandard_func_mode(!.ModuleInfo, PredA),
\+ pred_inst_info_is_nonstandard_func_mode(!.ModuleInfo, PredB),
GroundInstInfo = none
Index: compiler/instmap.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/instmap.m,v
retrieving revision 1.42
diff -u -b -r1.42 instmap.m
--- compiler/instmap.m 30 Aug 2005 04:11:52 -0000 1.42
+++ compiler/instmap.m 27 Sep 2005 17:11:46 -0000
@@ -615,30 +615,35 @@
%-----------------------------------------------------------------------------%
%-----------------------------------------------------------------------------%
- % instmap__merge(NonLocalVars, InstMaps, MergeContext):
- % Merge the `InstMaps' resulting from different branches of a disjunction
- % or if-then-else, and update the instantiatedness of all the nonlocal
- % variables, checking that it is the same for every branch.
+ % instmap__merge(NonLocals, InstMapList, MergeContext, !ModeInfo):
+ %
+ % Merge the `InstMapList' resulting from different branches of a
+ % disjunction or if-then-else, and update the instantiatedness of all
+ % the nonlocal variables, checking that it is the same for every branch.
%
instmap__merge(NonLocals, InstMapList, MergeContext, !ModeInfo) :-
mode_info_get_instmap(!.ModeInfo, InstMap0),
mode_info_get_module_info(!.ModeInfo, ModuleInfo0),
get_reachable_instmaps(InstMapList, InstMappingList),
- ( InstMappingList = [] ->
- InstMap = unreachable
- ; InstMap0 = reachable(InstMapping0) ->
+ (
+ % We can reach the code after the branched control structure only if
+ % (a) we can reach its start, and (b) some branch can reach the end.
+ InstMap0 = reachable(InstMapping0),
+ InstMappingList = [_ | _]
+ ->
set__to_sorted_list(NonLocals, NonLocalsList),
mode_info_get_var_types(!.ModeInfo, VarTypes),
instmap__merge_2(NonLocalsList, InstMapList, VarTypes,
InstMapping0, InstMapping, ModuleInfo0, ModuleInfo, ErrorList),
mode_info_set_module_info(ModuleInfo, !ModeInfo),
- ( ErrorList = [FirstError | _] ->
+ (
+ ErrorList = [FirstError | _],
FirstError = Var - _,
set__singleton_set(WaitingVars, Var),
mode_info_error(WaitingVars,
mode_error_disj(MergeContext, ErrorList), !ModeInfo)
;
- true
+ ErrorList = []
),
InstMap = reachable(InstMapping)
;
@@ -646,94 +651,167 @@
),
mode_info_set_instmap(InstMap, !ModeInfo).
-:- pred get_reachable_instmaps(list(instmap)::in,
- list(map(prog_var, inst))::out) is det.
+:- pred get_reachable_instmaps(list(instmap)::in, list(instmapping)::out)
+ is det.
get_reachable_instmaps([], []).
get_reachable_instmaps([InstMap | InstMaps], Reachables) :-
- ( InstMap = reachable(InstMapping) ->
- Reachables = [InstMapping | Reachables1],
- get_reachable_instmaps(InstMaps, Reachables1)
+ (
+ InstMap = reachable(InstMapping),
+ get_reachable_instmaps(InstMaps, ReachablesTail),
+ Reachables = [InstMapping | ReachablesTail]
;
+ InstMap = unreachable,
get_reachable_instmaps(InstMaps, Reachables)
).
%-----------------------------------------------------------------------------%
- % instmap__merge_2(Vars, InstMaps, ModuleInfo, ErrorList):
- % Let `ErrorList' be the list of variables in `Vars' for there are two
- % instmaps in `InstMaps' for which the inst the variable is incompatible.
+ % instmap__merge_2(Vars, InstMapList, VarTypes, !InstMapping, !ModuleInfo,
+ % Errors):
+ %
+ % Given Vars, a list of variables, and InstMapList, a list of instmaps
+ % giving the insts of those variables (and possibly others) at the ends of
+ % a branched control structure such as a disjunction or if-then-else,
+ % update !InstMapping, which initially gives the insts of variables at the
+ % start of the branched control structure, to reflect their insts at its
+ % end.
+ %
+ % For variables mentioned in Vars, merge their insts and put the merged
+ % inst into !:InstMapping. For variables not in Vars, leave their insts in
+ % !.InstMapping alone.
+ %
+ % If some variables in Vars have incompatible insts in two or more instmaps
+ % in InstMapList, return them in `Errors'.
%
:- pred instmap__merge_2(list(prog_var)::in, list(instmap)::in, vartypes::in,
instmapping::in, instmapping::out, module_info::in, module_info::out,
merge_errors::out) is det.
instmap__merge_2([], _, _, !InstMap, !ModuleInfo, []).
-instmap__merge_2([Var | Vars], InstMapList, VarTypes, !InstMap, !ModuleInfo,
- !:ErrorList) :-
- instmap__merge_2(Vars, InstMapList, VarTypes, !InstMap, !ModuleInfo,
+instmap__merge_2([Var | Vars], InstMapList, VarTypes, !InstMapping,
+ !ModuleInfo, !:ErrorList) :-
+ instmap__merge_2(Vars, InstMapList, VarTypes, !InstMapping, !ModuleInfo,
!:ErrorList),
- instmap__merge_var(InstMapList, Var, VarTypes ^ det_elem(Var),
- Insts, Inst, !ModuleInfo, Error),
+ map__lookup(VarTypes, Var, VarType),
+ list__map(lookup_var_in_instmap(Var), InstMapList, InstList),
+ instmap__merge_var(InstList, Var, VarType, !ModuleInfo, MaybeInst),
+ (
+ MaybeInst = no,
+ !:ErrorList = [Var - InstList | !.ErrorList],
+ svmap__set(Var, not_reached, !InstMapping)
+ ;
+ MaybeInst = yes(Inst),
+ svmap__set(Var, Inst, !InstMapping)
+ ).
+
+:- pred lookup_var_in_instmap(prog_var::in, instmap::in, (inst)::out) is det.
+
+lookup_var_in_instmap(Var, InstMap, Inst) :-
+ instmap__lookup_var(InstMap, Var, Inst).
+
+ % instmap__merge_var(Insts, Var, Type, Inst, !ModuleInfo, !Error):
+ %
+ % Given a list of insts of the given variable that reflect the inst of that
+ % variable at the ends of a branched control structure such as a
+ % disjunction or if-then-else, return the final inst of that variable
+ % after the branched control structure as a whole.
+ %
+ % Set !:Error to yes if two insts of the variable are incompatible.
+ %
+ % We used to use a straightforward algorithm that, given a list of N insts,
+ % merged the tail N-1 insts, and merged the result with the head inst.
+ % While this is simple and efficient for small N, it has very bad
+ % performance for large N. The reason is that its complexity can be N^2,
+ % since in many cases each arm of the branched control structure binds
+ % Var to a different function symbol, and this means that the inst of Var
+ % evolves like this:
+ %
+ % bound(f)
+ % bound(f; g)
+ % bound(f; g; h)
+ % bound(f; g; h; i)
+ %
+ % Our current algorithm uses a number of passes, each of which divides the
+ % number of insts in half by merging adjacent pairs of insts. The overall
+ % complexity is thus N log N, not N^2.
+ %
+:- pred instmap__merge_var(list(inst)::in, prog_var::in, (type)::in,
+ module_info::in, module_info::out, maybe(inst)::out) is det.
+
+instmap__merge_var(Insts, Var, Type, !ModuleInfo, MaybeMergedInst) :-
+ instmap__merge_var_2(Insts, Var, Type, [], MergedInsts, !ModuleInfo,
+ no, Error),
(
Error = yes,
- !:ErrorList = [Var - Insts | !.ErrorList],
- svmap__set(Var, not_reached, !InstMap)
+ MaybeMergedInst = no
;
Error = no,
- svmap__set(Var, Inst, !InstMap)
+ (
+ MergedInsts = [],
+ MaybeMergedInst = yes(not_reached)
+ ;
+ MergedInsts = [MergedInst],
+ MaybeMergedInst = yes(MergedInst)
+ ;
+ MergedInsts = [_, _ | _],
+ instmap__merge_var(MergedInsts, Var, Type, !ModuleInfo,
+ MaybeMergedInst)
+ )
).
- % instmap_merge_var(InstMaps, Var, ModuleInfo, Insts, Error):
- %
- % Let `Insts' be the list of the inst of `Var' in the corresponding
- % `InstMaps'. Let `Error' be yes iff there are two instmaps
- % for which the inst of `Var' is incompatible.
- %
-:- pred instmap__merge_var(list(instmap)::in, prog_var::in, (type)::in,
- list(inst)::out, (inst)::out, module_info::in, module_info::out,
- bool::out) is det.
-
-instmap__merge_var([], _, _, [], not_reached, !ModuleInfo, no).
-instmap__merge_var([InstMap | InstMaps], Var, Type, InstList, Inst,
- !ModuleInfo, Error) :-
- instmap__merge_var(InstMaps, Var, Type, InstList0, Inst0, !ModuleInfo,
- Error0),
- instmap__lookup_var(InstMap, Var, VarInst),
- InstList = [VarInst | InstList0],
- ( inst_merge(Inst0, VarInst, yes(Type), Inst1, !ModuleInfo) ->
- Inst = Inst1,
- Error = Error0
+:- pred instmap__merge_var_2(list(inst)::in, prog_var::in, (type)::in,
+ list(inst)::in, list(inst)::out, module_info::in, module_info::out,
+ bool::in, bool::out) is det.
+
+instmap__merge_var_2([], _, _, !MergedInsts, !ModuleInfo, !Error).
+instmap__merge_var_2([Inst], _Var, _Type, !MergedInsts, !ModuleInfo, !Error) :-
+ !:MergedInsts = [Inst | !.MergedInsts].
+instmap__merge_var_2([Inst1, Inst2 | Insts], Var, Type, !MergedInsts,
+ !ModuleInfo, !Error) :-
+ ( inst_merge(Inst1, Inst2, yes(Type), MergedInst, !ModuleInfo) ->
+ !:MergedInsts = [MergedInst | !.MergedInsts],
+ instmap__merge_var_2(Insts, Var, Type, !MergedInsts, !ModuleInfo,
+ !Error)
;
- Error = yes,
- Inst = not_reached
+ !:Error = yes
).
%-----------------------------------------------------------------------------%
-merge_instmap_deltas(InstMap, NonLocals, VarTypes, InstMapDeltaList,
+ % We use the same technique for merge_instmap_deltas as for merge_var,
+ % and for the same reason.
+merge_instmap_deltas(InstMap, NonLocals, VarTypes, Deltas,
MergedDelta, !ModuleInfo) :-
+ merge_instmap_deltas_2(InstMap, NonLocals, VarTypes, Deltas,
+ [], MergedDeltas, !ModuleInfo),
(
- InstMapDeltaList = [],
+ MergedDeltas = [],
error("merge_instmap_deltas: empty instmap_delta list.")
;
- InstMapDeltaList = [Delta | Deltas],
- merge_instmap_deltas(InstMap, NonLocals, VarTypes, Delta,
- Deltas, MergedDelta, !ModuleInfo)
+ MergedDeltas = [MergedDelta]
+ ;
+ MergedDeltas = [_, _ | _],
+ merge_instmap_deltas(InstMap, NonLocals, VarTypes, MergedDeltas,
+ MergedDelta, !ModuleInfo)
).
-:- pred merge_instmap_deltas(instmap::in, set(prog_var)::in, vartypes::in,
- instmap_delta::in, list(instmap_delta)::in, instmap_delta::out,
+:- pred merge_instmap_deltas_2(instmap::in, set(prog_var)::in, vartypes::in,
+ list(instmap_delta)::in, list(instmap_delta)::in, list(instmap_delta)::out,
module_info::in, module_info::out) is det.
-merge_instmap_deltas(_InstMap, _NonLocals, _VarTypes, MergedDelta, [],
- MergedDelta, !ModuleInfo).
-merge_instmap_deltas(InstMap, NonLocals, VarTypes, MergedDelta0, [Delta|Deltas],
- MergedDelta, !ModuleInfo) :-
- merge_instmap_delta(InstMap, NonLocals, VarTypes, MergedDelta0, Delta,
- MergedDelta1, !ModuleInfo),
- merge_instmap_deltas(InstMap, NonLocals, VarTypes, MergedDelta1, Deltas,
- MergedDelta, !ModuleInfo).
+merge_instmap_deltas_2(_InstMap, _NonLocals, _VarTypes, [], !MergedDeltas,
+ !ModuleInfo).
+merge_instmap_deltas_2(_InstMap, _NonLocals, _VarTypes, [Delta], !MergedDeltas,
+ !ModuleInfo) :-
+ !:MergedDeltas = [Delta | !.MergedDeltas].
+merge_instmap_deltas_2(InstMap, NonLocals, VarTypes, [Delta1, Delta2 | Deltas],
+ !MergedDeltas, !ModuleInfo) :-
+ merge_instmap_delta(InstMap, NonLocals, VarTypes, Delta1, Delta2,
+ MergedDelta, !ModuleInfo),
+ !:MergedDeltas = [MergedDelta | !.MergedDeltas],
+ merge_instmap_deltas_2(InstMap, NonLocals, VarTypes, Deltas,
+ !MergedDeltas, !ModuleInfo).
%-----------------------------------------------------------------------------%
Index: compiler/mode_util.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/mode_util.m,v
retrieving revision 1.172
diff -u -b -r1.172 mode_util.m
--- compiler/mode_util.m 22 Sep 2005 06:15:25 -0000 1.172
+++ compiler/mode_util.m 27 Sep 2005 18:09:01 -0000
@@ -1143,26 +1143,6 @@
%-----------------------------------------------------------------------------%
-:- pred recompute_instmap_delta_disj(bool::in, list(hlds_goal)::in,
- list(hlds_goal)::out, vartypes::in, instmap::in, set(prog_var)::in,
- instmap_delta::out, recompute_info::in, recompute_info::out) is det.
-
-recompute_instmap_delta_disj(_, [], [], _, _, _, InstMapDelta, !RI) :-
- instmap_delta_init_unreachable(InstMapDelta).
-recompute_instmap_delta_disj(Atomic, [Goal0], [Goal],
- VarTypes, InstMap, _, InstMapDelta, !RI) :-
- recompute_instmap_delta_1(Atomic, Goal0, Goal, VarTypes, InstMap,
- InstMapDelta, !RI).
-recompute_instmap_delta_disj(Atomic, [Goal0 | Goals0], [Goal | Goals],
- VarTypes, InstMap, NonLocals, InstMapDelta, !RI) :-
- Goals0 = [_ | _],
- recompute_instmap_delta_1(Atomic, Goal0, Goal,
- VarTypes, InstMap, InstMapDelta0, !RI),
- recompute_instmap_delta_disj(Atomic, Goals0, Goals,
- VarTypes, InstMap, NonLocals, InstMapDelta1, !RI),
- update_module_info(merge_instmap_delta(InstMap, NonLocals,
- VarTypes, InstMapDelta0, InstMapDelta1), InstMapDelta, !RI).
-
:- pred recompute_instmap_delta_par_conj(bool::in, list(hlds_goal)::in,
list(hlds_goal)::out, vartypes::in, instmap::in, set(prog_var)::in,
instmap_delta::out, recompute_info::in, recompute_info::out) is det.
@@ -1185,27 +1165,76 @@
%-----------------------------------------------------------------------------%
+:- pred recompute_instmap_delta_disj(bool::in, list(hlds_goal)::in,
+ list(hlds_goal)::out, vartypes::in, instmap::in, set(prog_var)::in,
+ instmap_delta::out, recompute_info::in, recompute_info::out) is det.
+
+recompute_instmap_delta_disj(Atomic, Goals0, Goals, VarTypes, InstMap,
+ NonLocals, InstMapDelta, !RI) :-
+ recompute_instmap_delta_disj_2(Atomic, Goals0, Goals, VarTypes, InstMap,
+ NonLocals, InstMapDeltas, !RI),
+ (
+ InstMapDeltas = [],
+ instmap_delta_init_unreachable(InstMapDelta)
+ ;
+ InstMapDeltas = [_ | _],
+ update_module_info(
+ merge_instmap_deltas(InstMap, NonLocals, VarTypes, InstMapDeltas),
+ InstMapDelta, !RI)
+ ).
+
+:- pred recompute_instmap_delta_disj_2(bool::in, list(hlds_goal)::in,
+ list(hlds_goal)::out, vartypes::in, instmap::in, set(prog_var)::in,
+ list(instmap_delta)::out, recompute_info::in, recompute_info::out) is det.
+
+recompute_instmap_delta_disj_2(_Atomic, [], [],
+ _VarTypes, _InstMap, _NonLocals, [], !RI).
+recompute_instmap_delta_disj_2(Atomic, [Goal0 | Goals0], [Goal | Goals],
+ VarTypes, InstMap, NonLocals, [InstMapDelta | InstMapDeltas], !RI) :-
+ recompute_instmap_delta_1(Atomic, Goal0, Goal,
+ VarTypes, InstMap, InstMapDelta, !RI),
+ recompute_instmap_delta_disj_2(Atomic, Goals0, Goals,
+ VarTypes, InstMap, NonLocals, InstMapDeltas, !RI).
+
+%-----------------------------------------------------------------------------%
+
:- pred recompute_instmap_delta_cases(bool::in, prog_var::in, list(case)::in,
list(case)::out, vartypes::in, instmap::in, set(prog_var)::in,
instmap_delta::out, recompute_info::in, recompute_info::out) is det.
-recompute_instmap_delta_cases(_, _, [], [], _, _, _, InstMapDelta, !RI) :-
- instmap_delta_init_unreachable(InstMapDelta).
-recompute_instmap_delta_cases(Atomic, Var, [Case0 | Cases0], [Case | Cases],
- VarTypes, InstMap0, NonLocals, InstMapDelta, !RI) :-
+recompute_instmap_delta_cases(Atomic, Var, Cases0, Cases, VarTypes,
+ InstMap0, NonLocals, InstMapDelta, !RI) :-
+ recompute_instmap_delta_cases_2(Atomic, Var, Cases0, Cases, VarTypes,
+ InstMap0, NonLocals, InstMapDeltas, !RI),
+ (
+ InstMapDeltas = [],
+ instmap_delta_init_unreachable(InstMapDelta)
+ ;
+ InstMapDeltas = [_ | _],
+ update_module_info(
+ merge_instmap_deltas(InstMap0, NonLocals, VarTypes, InstMapDeltas),
+ InstMapDelta, !RI)
+ ).
+
+:- pred recompute_instmap_delta_cases_2(bool::in, prog_var::in, list(case)::in,
+ list(case)::out, vartypes::in, instmap::in, set(prog_var)::in,
+ list(instmap_delta)::out, recompute_info::in, recompute_info::out) is det.
+
+recompute_instmap_delta_cases_2(_Atomic, _Var, [], [],
+ _VarTypes, _InstMap, _NonLocals, [], !RI).
+recompute_instmap_delta_cases_2(Atomic, Var, [Case0 | Cases0], [Case | Cases],
+ VarTypes, InstMap0, NonLocals, [InstMapDelta | InstMapDeltas], !RI) :-
Case0 = case(Functor, Goal0),
map__lookup(VarTypes, Var, Type),
update_module_info(instmap__bind_var_to_functor(Var, Type, Functor,
- InstMap0), InstMap, !RI),
- recompute_instmap_delta_1(Atomic, Goal0, Goal, VarTypes, InstMap,
+ InstMap0), InstMap1, !RI),
+ recompute_instmap_delta_1(Atomic, Goal0, Goal, VarTypes, InstMap1,
InstMapDelta0, !RI),
update_module_info(instmap_delta_bind_var_to_functor(Var, Type,
- Functor, InstMap0, InstMapDelta0), InstMapDelta1, !RI),
+ Functor, InstMap0, InstMapDelta0), InstMapDelta, !RI),
Case = case(Functor, Goal),
- recompute_instmap_delta_cases(Atomic, Var, Cases0, Cases,
- VarTypes, InstMap0, NonLocals, InstMapDelta2, !RI),
- update_module_info(merge_instmap_delta(InstMap0, NonLocals,
- VarTypes, InstMapDelta1, InstMapDelta2), InstMapDelta, !RI).
+ recompute_instmap_delta_cases_2(Atomic, Var, Cases0, Cases,
+ VarTypes, InstMap0, NonLocals, InstMapDeltas, !RI).
%-----------------------------------------------------------------------------%
Index: compiler/modes.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/modes.m,v
retrieving revision 1.312
diff -u -b -r1.312 modes.m
--- compiler/modes.m 26 Sep 2005 05:48:09 -0000 1.312
+++ compiler/modes.m 27 Sep 2005 02:54:41 -0000
@@ -1333,8 +1333,7 @@
Disjs0 = [_ | _],
goal_info_get_nonlocals(GoalInfo0, NonLocals),
- modecheck_disj_list(Disjs0, Disjs1, InstMapList0,
- !ModeInfo, !IO),
+ modecheck_disj_list(Disjs0, Disjs1, InstMapList0, !ModeInfo, !IO),
mode_info_get_var_types(!.ModeInfo, VarTypes),
handle_solver_vars_in_disjs(set__to_sorted_list(NonLocals),
VarTypes, Disjs1, Disjs2, InstMapList0, InstMapList, !ModeInfo),
cvs diff: Diffing compiler/notes
cvs diff: Diffing debian
cvs diff: Diffing debian/patches
cvs diff: Diffing deep_profiler
cvs diff: Diffing deep_profiler/notes
cvs diff: Diffing doc
cvs diff: Diffing extras
cvs diff: Diffing extras/aditi
cvs diff: Diffing extras/cgi
cvs diff: Diffing extras/complex_numbers
cvs diff: Diffing extras/complex_numbers/samples
cvs diff: Diffing extras/complex_numbers/tests
cvs diff: Diffing extras/concurrency
cvs diff: Diffing extras/curs
cvs diff: Diffing extras/curs/samples
cvs diff: Diffing extras/curses
cvs diff: Diffing extras/curses/sample
cvs diff: Diffing extras/dynamic_linking
cvs diff: Diffing extras/error
cvs diff: Diffing extras/graphics
cvs diff: Diffing extras/graphics/easyx
cvs diff: Diffing extras/graphics/easyx/samples
cvs diff: Diffing extras/graphics/mercury_glut
cvs diff: Diffing extras/graphics/mercury_opengl
cvs diff: Diffing extras/graphics/mercury_tcltk
cvs diff: Diffing extras/graphics/samples
cvs diff: Diffing extras/graphics/samples/calc
cvs diff: Diffing extras/graphics/samples/gears
cvs diff: Diffing extras/graphics/samples/maze
cvs diff: Diffing extras/graphics/samples/pent
cvs diff: Diffing extras/lazy_evaluation
cvs diff: Diffing extras/lex
cvs diff: Diffing extras/lex/samples
cvs diff: Diffing extras/lex/tests
cvs diff: Diffing extras/logged_output
cvs diff: Diffing extras/moose
cvs diff: Diffing extras/moose/samples
cvs diff: Diffing extras/moose/tests
cvs diff: Diffing extras/morphine
cvs diff: Diffing extras/morphine/non-regression-tests
cvs diff: Diffing extras/morphine/scripts
cvs diff: Diffing extras/morphine/source
cvs diff: Diffing extras/odbc
cvs diff: Diffing extras/posix
cvs diff: Diffing extras/quickcheck
cvs diff: Diffing extras/quickcheck/tutes
cvs diff: Diffing extras/references
cvs diff: Diffing extras/references/samples
cvs diff: Diffing extras/references/tests
cvs diff: Diffing extras/solver_types
cvs diff: Diffing extras/solver_types/library
cvs diff: Diffing extras/stream
cvs diff: Diffing extras/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing extras/xml
cvs diff: Diffing extras/xml/samples
cvs diff: Diffing extras/xml_stylesheets
cvs diff: Diffing java
cvs diff: Diffing java/runtime
cvs diff: Diffing library
cvs diff: Diffing mdbcomp
cvs diff: Diffing profiler
cvs diff: Diffing robdd
cvs diff: Diffing runtime
cvs diff: Diffing runtime/GETOPT
cvs diff: Diffing runtime/machdeps
cvs diff: Diffing samples
cvs diff: Diffing samples/c_interface
cvs diff: Diffing samples/c_interface/c_calls_mercury
cvs diff: Diffing samples/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/c_interface/mercury_calls_c
cvs diff: Diffing samples/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/diff
cvs diff: Diffing samples/muz
cvs diff: Diffing samples/rot13
cvs diff: Diffing samples/solutions
cvs diff: Diffing samples/tests
cvs diff: Diffing samples/tests/c_interface
cvs diff: Diffing samples/tests/c_interface/c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/cplusplus_calls_mercury
cvs diff: Diffing samples/tests/c_interface/mercury_calls_c
cvs diff: Diffing samples/tests/c_interface/mercury_calls_cplusplus
cvs diff: Diffing samples/tests/c_interface/mercury_calls_fortran
cvs diff: Diffing samples/tests/c_interface/simpler_c_calls_mercury
cvs diff: Diffing samples/tests/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/tests/diff
cvs diff: Diffing samples/tests/muz
cvs diff: Diffing samples/tests/rot13
cvs diff: Diffing samples/tests/solutions
cvs diff: Diffing samples/tests/toplevel
cvs diff: Diffing scripts
cvs diff: Diffing slice
cvs diff: Diffing tests
cvs diff: Diffing tests/benchmarks
cvs diff: Diffing tests/debugger
cvs diff: Diffing tests/debugger/declarative
cvs diff: Diffing tests/dppd
cvs diff: Diffing tests/general
cvs diff: Diffing tests/general/accumulator
cvs diff: Diffing tests/general/string_format
cvs diff: Diffing tests/general/structure_reuse
cvs diff: Diffing tests/grade_subdirs
cvs diff: Diffing tests/hard_coded
cvs diff: Diffing tests/hard_coded/exceptions
cvs diff: Diffing tests/hard_coded/purity
cvs diff: Diffing tests/hard_coded/sub-modules
cvs diff: Diffing tests/hard_coded/typeclasses
cvs diff: Diffing tests/invalid
cvs diff: Diffing tests/invalid/purity
cvs diff: Diffing tests/misc_tests
cvs diff: Diffing tests/mmc_make
cvs diff: Diffing tests/mmc_make/lib
cvs diff: Diffing tests/recompilation
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/valid
cvs diff: Diffing tests/warnings
cvs diff: Diffing tools
cvs diff: Diffing trace
cvs diff: Diffing util
cvs diff: Diffing vim
cvs diff: Diffing vim/after
cvs diff: Diffing vim/ftplugin
cvs diff: Diffing vim/syntax
--------------------------------------------------------------------------
mercury-reviews mailing list
post: mercury-reviews at cs.mu.oz.au
administrative address: owner-mercury-reviews at cs.mu.oz.au
unsubscribe: Address: mercury-reviews-request at cs.mu.oz.au Message: unsubscribe
subscribe: Address: mercury-reviews-request at cs.mu.oz.au Message: subscribe
--------------------------------------------------------------------------
More information about the reviews
mailing list