[m-rev.] For post-commit review: Coverage profiler no-longer instruments deep profiler instrumentation goals.
Zoltan Somogyi
zs at csse.unimelb.edu.au
Tue Sep 16 18:57:54 AEST 2008
On 14-Sep-2008, Paul Bone <pbone at csse.unimelb.edu.au> wrote:
> For post-commit review by Zoltan
Post-commit review of Paul's latest change to coverage profiling, together
with some misc cleanups.
compiler/deep_profiling.m:
Give some predicates and types more specific names.
Fix some misleading variable names and some misleading comments.
Make some comments more readable.
Avoid unmanageably-deeply nested code.
Factor out some common code.
Mark suspect code and unrevealing documentation with XXXs.
compiler/hlds_goal.m:
Make some comments more readable.
compiler/hlds_out.m:
Write out more useful information in less (horizontal) space.
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/libatomic_ops-1.2
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/doc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/gcc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/hpc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/ibmc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/icc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/msftc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/src/atomic_ops/sysdeps/sunc
cvs diff: Diffing boehm_gc/libatomic_ops-1.2/tests
cvs diff: Diffing boehm_gc/tests
cvs diff: Diffing boehm_gc/windows-untested
cvs diff: Diffing boehm_gc/windows-untested/vc60
cvs diff: Diffing boehm_gc/windows-untested/vc70
cvs diff: Diffing boehm_gc/windows-untested/vc71
cvs diff: Diffing browser
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/deep_profiling.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/deep_profiling.m,v
retrieving revision 1.81
diff -u -b -r1.81 deep_profiling.m
--- compiler/deep_profiling.m 14 Sep 2008 03:52:53 -0000 1.81
+++ compiler/deep_profiling.m 16 Sep 2008 08:54:13 -0000
@@ -75,7 +75,7 @@
TailRecursion),
(
TailRecursion = yes,
- apply_tail_recursion_transformation(!ModuleInfo)
+ apply_deep_prof_tail_rec_transform(!ModuleInfo)
;
TailRecursion = no
),
@@ -88,26 +88,26 @@
%-----------------------------------------------------------------------------%
-:- pred apply_tail_recursion_transformation(module_info::in, module_info::out)
+:- pred apply_deep_prof_tail_rec_transform(module_info::in, module_info::out)
is det.
-apply_tail_recursion_transformation(!ModuleInfo) :-
+apply_deep_prof_tail_rec_transform(!ModuleInfo) :-
module_info_ensure_dependency_info(!ModuleInfo),
module_info_dependency_info(!.ModuleInfo, DepInfo),
hlds_dependency_info_get_dependency_ordering(DepInfo, SCCs),
- list.foldl(apply_tail_recursion_to_scc, SCCs, !ModuleInfo).
+ list.foldl(apply_deep_prof_tail_rec_transform_to_scc, SCCs, !ModuleInfo).
-:- pred apply_tail_recursion_to_scc(list(pred_proc_id)::in,
+:- pred apply_deep_prof_tail_rec_transform_to_scc(list(pred_proc_id)::in,
module_info::in, module_info::out) is det.
-apply_tail_recursion_to_scc(SCC, !ModuleInfo) :-
+apply_deep_prof_tail_rec_transform_to_scc(SCC, !ModuleInfo) :-
% For the time being, we only look for self-tail-recursive calls.
- list.foldl(apply_tail_recursion_to_proc, SCC, !ModuleInfo).
+ list.foldl(apply_deep_prof_tail_rec_transform_to_proc, SCC, !ModuleInfo).
-:- pred apply_tail_recursion_to_proc(pred_proc_id::in,
+:- pred apply_deep_prof_tail_rec_transform_to_proc(pred_proc_id::in,
module_info::in, module_info::out) is det.
-apply_tail_recursion_to_proc(PredProcId, !ModuleInfo) :-
+apply_deep_prof_tail_rec_transform_to_proc(PredProcId, !ModuleInfo) :-
PredProcId = proc(PredId, ProcId),
module_info_preds(!.ModuleInfo, PredTable0),
map.lookup(PredTable0, PredId, PredInfo0),
@@ -125,10 +125,10 @@
Outputs),
clone_proc_id(ProcTable0, ProcId, CloneProcId),
ClonePredProcId = proc(PredId, CloneProcId),
- ApplyInfo = apply_tail_recursion_info(!.ModuleInfo,
+ TailRecInfo = deep_prof_tail_rec_info(!.ModuleInfo,
[PredProcId - ClonePredProcId], Detism, Outputs),
- apply_tail_recursion_to_goal(Goal0, Goal, ApplyInfo, no, FoundTailCall,
- _),
+ apply_deep_prof_tail_rec_to_goal(Goal0, Goal, TailRecInfo,
+ no, FoundTailCall, _Continue),
FoundTailCall = yes
->
proc_info_set_goal(Goal, ProcInfo0, ProcInfo1),
@@ -186,19 +186,19 @@
%-----------------------------------------------------------------------------%
-:- type apply_tail_recursion_info
- ---> apply_tail_recursion_info(
- moduleinfo :: module_info,
- scc_ppids :: assoc_list(pred_proc_id),
- detism :: determinism,
- outputs :: list(prog_var)
+:- type deep_prof_tail_rec_info
+ ---> deep_prof_tail_rec_info(
+ dptri_moduleinfo :: module_info,
+ dptri_scc_ppids :: assoc_list(pred_proc_id),
+ dptri_detism :: determinism,
+ dptri_outputs :: list(prog_var)
).
-:- pred apply_tail_recursion_to_goal(hlds_goal::in, hlds_goal::out,
- apply_tail_recursion_info::in, bool::in, bool::out,
+:- pred apply_deep_prof_tail_rec_to_goal(hlds_goal::in, hlds_goal::out,
+ deep_prof_tail_rec_info::in, bool::in, bool::out,
maybe(list(prog_var))::out) is det.
-apply_tail_recursion_to_goal(Goal0, Goal, ApplyInfo, !FoundTailCall,
+apply_deep_prof_tail_rec_to_goal(Goal0, Goal, TailRecInfo, !FoundTailCall,
Continue) :-
Goal0 = hlds_goal(GoalExpr0, GoalInfo0),
(
@@ -210,17 +210,17 @@
SymName),
(
PredProcId = proc(PredId, ProcId),
- assoc_list.search(ApplyInfo ^ scc_ppids, PredProcId,
+ assoc_list.search(TailRecInfo ^ dptri_scc_ppids, PredProcId,
ClonePredProcId),
- module_info_pred_proc_info(ApplyInfo ^ moduleinfo,
+ module_info_pred_proc_info(TailRecInfo ^ dptri_moduleinfo,
PredId, ProcId, PredInfo, ProcInfo),
proc_info_interface_determinism(ProcInfo, CallDetism),
- CallDetism = ApplyInfo ^ detism,
+ CallDetism = TailRecInfo ^ dptri_detism,
pred_info_get_arg_types(PredInfo, Types),
proc_info_get_argmodes(ProcInfo, Modes),
find_list_of_output_args(Args, Modes, Types,
- ApplyInfo ^ moduleinfo, CallOutputs),
- CallOutputs = ApplyInfo ^ outputs,
+ TailRecInfo ^ dptri_moduleinfo, CallOutputs),
+ CallOutputs = TailRecInfo ^ dptri_outputs,
Builtin = not_builtin
->
ClonePredProcId = proc(ClonePredId, CloneProcId),
@@ -242,7 +242,7 @@
Goal = Goal0,
(
Unify0 = assign(ToVar, FromVar),
- apply_tail_recursion_process_assign(ApplyInfo ^ outputs,
+ apply_deep_prof_tail_rec_to_assign(TailRecInfo ^ dptri_outputs,
ToVar, FromVar, Outputs),
Continue = yes(Outputs)
;
@@ -257,7 +257,7 @@
GoalExpr0 = conj(ConjType, Goals0),
(
ConjType = plain_conj,
- apply_tail_recursion_to_conj(Goals0, Goals, ApplyInfo,
+ apply_deep_prof_tail_rec_to_conj(Goals0, Goals, TailRecInfo,
!FoundTailCall, Continue),
GoalExpr = conj(ConjType, Goals),
Goal = hlds_goal(GoalExpr, GoalInfo0)
@@ -268,22 +268,23 @@
)
;
GoalExpr0 = disj(Goals0),
- apply_tail_recursion_to_disj(Goals0, Goals, ApplyInfo, !FoundTailCall),
+ apply_deep_prof_tail_rec_to_disj(Goals0, Goals, TailRecInfo,
+ !FoundTailCall),
GoalExpr = disj(Goals),
Goal = hlds_goal(GoalExpr, GoalInfo0),
Continue = no
;
GoalExpr0 = switch(Var, CanFail, Cases0),
- apply_tail_recursion_to_cases(Cases0, Cases, ApplyInfo,
+ apply_deep_prof_tail_rec_to_cases(Cases0, Cases, TailRecInfo,
!FoundTailCall),
GoalExpr = switch(Var, CanFail, Cases),
Goal = hlds_goal(GoalExpr, GoalInfo0),
Continue = no
;
GoalExpr0 = if_then_else(Vars, Cond, Then0, Else0),
- apply_tail_recursion_to_goal(Then0, Then, ApplyInfo,
+ apply_deep_prof_tail_rec_to_goal(Then0, Then, TailRecInfo,
!FoundTailCall, _),
- apply_tail_recursion_to_goal(Else0, Else, ApplyInfo,
+ apply_deep_prof_tail_rec_to_goal(Else0, Else, TailRecInfo,
!FoundTailCall, _),
GoalExpr = if_then_else(Vars, Cond, Then, Else),
Goal = hlds_goal(GoalExpr, GoalInfo0),
@@ -298,63 +299,70 @@
Continue = no
;
GoalExpr0 = shorthand(_),
- unexpected(this_file, "shorthand in apply_tail_recursion_to_goal")
+ unexpected(this_file, "shorthand in apply_deep_prof_tail_rec_to_goal")
).
-:- pred apply_tail_recursion_process_assign(list(prog_var)::in,
+:- pred apply_deep_prof_tail_rec_to_assign(list(prog_var)::in,
prog_var::in, prog_var::in, list(prog_var)::out) is det.
-apply_tail_recursion_process_assign([], _, _, []).
-apply_tail_recursion_process_assign([Output0 | Outputs0], ToVar, FromVar,
+apply_deep_prof_tail_rec_to_assign([], _, _, []).
+apply_deep_prof_tail_rec_to_assign([Output0 | Outputs0], ToVar, FromVar,
[Output | Outputs]) :-
( ToVar = Output0 ->
Output = FromVar
;
Output = Output0
),
- apply_tail_recursion_process_assign(Outputs0, ToVar, FromVar, Outputs).
+ apply_deep_prof_tail_rec_to_assign(Outputs0, ToVar, FromVar, Outputs).
-:- pred apply_tail_recursion_to_conj(list(hlds_goal)::in,
- list(hlds_goal)::out, apply_tail_recursion_info::in,
+:- pred apply_deep_prof_tail_rec_to_conj(list(hlds_goal)::in,
+ list(hlds_goal)::out, deep_prof_tail_rec_info::in,
bool::in, bool::out, maybe(list(prog_var))::out) is det.
-apply_tail_recursion_to_conj([], [], ApplyInfo,
- !FoundTailCall, yes(ApplyInfo ^ outputs)).
-apply_tail_recursion_to_conj([Goal0 | Goals0], [Goal | Goals], ApplyInfo0,
+apply_deep_prof_tail_rec_to_conj([], [], TailRecInfo,
+ !FoundTailCall, yes(TailRecInfo ^ dptri_outputs)).
+apply_deep_prof_tail_rec_to_conj([Goal0 | Goals0], [Goal | Goals], TailRecInfo,
!FoundTailCall, Continue) :-
- apply_tail_recursion_to_conj(Goals0, Goals, ApplyInfo0, !FoundTailCall,
- Continue1),
+ apply_deep_prof_tail_rec_to_conj(Goals0, Goals, TailRecInfo,
+ !FoundTailCall, TailContinue),
(
- Continue1 = yes(Outputs),
- apply_tail_recursion_to_goal(Goal0, Goal,
- ApplyInfo0 ^ outputs := Outputs, !FoundTailCall, Continue)
+ TailContinue = yes(Outputs),
+ HeadTailRecInfo = TailRecInfo ^ dptri_outputs := Outputs,
+ apply_deep_prof_tail_rec_to_goal(Goal0, Goal, HeadTailRecInfo,
+ !FoundTailCall, Continue)
;
- Continue1 = no,
+ TailContinue = no,
Goal = Goal0,
Continue = no
).
-:- pred apply_tail_recursion_to_disj(list(hlds_goal)::in, list(hlds_goal)::out,
- apply_tail_recursion_info::in, bool::in, bool::out) is det.
+:- pred apply_deep_prof_tail_rec_to_disj(list(hlds_goal)::in,
+ list(hlds_goal)::out, deep_prof_tail_rec_info::in, bool::in, bool::out)
+ is det.
-apply_tail_recursion_to_disj([], [], _, !FoundTailCall).
-apply_tail_recursion_to_disj([Goal0], [Goal], ApplyInfo, !FoundTailCall) :-
- apply_tail_recursion_to_goal(Goal0, Goal, ApplyInfo, !FoundTailCall, _).
-apply_tail_recursion_to_disj([Goal0 | Goals0], [Goal0 | Goals], ApplyInfo,
+apply_deep_prof_tail_rec_to_disj([], [], _, !FoundTailCall).
+apply_deep_prof_tail_rec_to_disj([Goal0], [Goal], TailRecInfo,
!FoundTailCall) :-
+ apply_deep_prof_tail_rec_to_goal(Goal0, Goal, TailRecInfo, !FoundTailCall,
+ _).
+apply_deep_prof_tail_rec_to_disj([Goal0 | Goals0], [Goal0 | Goals],
+ TailRecInfo, !FoundTailCall) :-
Goals0 = [_ | _],
- apply_tail_recursion_to_disj(Goals0, Goals, ApplyInfo, !FoundTailCall).
+ apply_deep_prof_tail_rec_to_disj(Goals0, Goals, TailRecInfo,
+ !FoundTailCall).
-:- pred apply_tail_recursion_to_cases(list(case)::in, list(case)::out,
- apply_tail_recursion_info::in, bool::in, bool::out) is det.
+:- pred apply_deep_prof_tail_rec_to_cases(list(case)::in, list(case)::out,
+ deep_prof_tail_rec_info::in, bool::in, bool::out) is det.
-apply_tail_recursion_to_cases([], [], _, !FoundTailCall).
-apply_tail_recursion_to_cases([Case0 | Cases0], [Case | Cases], ApplyInfo,
- !FoundTailCall) :-
+apply_deep_prof_tail_rec_to_cases([], [], _, !FoundTailCall).
+apply_deep_prof_tail_rec_to_cases([Case0 | Cases0], [Case | Cases],
+ TailRecInfo, !FoundTailCall) :-
Case0 = case(MainConsId, OtherConsIds, Goal0),
- apply_tail_recursion_to_goal(Goal0, Goal, ApplyInfo, !FoundTailCall, _),
+ apply_deep_prof_tail_rec_to_goal(Goal0, Goal, TailRecInfo,
+ !FoundTailCall, _),
Case = case(MainConsId, OtherConsIds, Goal),
- apply_tail_recursion_to_cases(Cases0, Cases, ApplyInfo, !FoundTailCall).
+ apply_deep_prof_tail_rec_to_cases(Cases0, Cases, TailRecInfo,
+ !FoundTailCall).
%-----------------------------------------------------------------------------%
@@ -413,7 +421,7 @@
figure_out_rec_call_numbers(Goal1, !N, !TailCallSites)
;
GoalExpr = shorthand(_),
- unexpected(this_file, "shorthand in apply_tail_recursion_to_goal")
+ unexpected(this_file, "shorthand in figure_out_rec_call_numbers")
).
:- pred figure_out_rec_call_numbers_in_goal_list(list(hlds_goal)::in,
@@ -965,14 +973,15 @@
% erlang_rtti_implementation.deconstruct_2/9-2 whose switch's type has
% 25 constructors yet this computes 27. Are constructors different to
% functors?
- %ModuleInfo = !.DeepInfo ^ deep_module_info,
- %VarTypes = !.DeepInfo ^ deep_varinfos ^ varinfo_vartypes,
- %map.lookup(VarTypes, Var, Type),
- %( switch_type_num_functors(ModuleInfo, Type, NumFunctors) ->
+ % zs: this computation is NOT broken.
+ % ModuleInfo = !.DeepInfo ^ deep_module_info,
+ % VarTypes = !.DeepInfo ^ deep_varinfos ^ varinfo_vartypes,
+ % map.lookup(VarTypes, Var, Type),
+ % ( switch_type_num_functors(ModuleInfo, Type, NumFunctors) ->
% MaybeNumFunctors = yes(NumFunctors)
- %;
+ % ;
% MaybeNumFunctors = no
- %),
+ % ),
MaybeNumFunctors = no,
deep_prof_transform_switch(MaybeNumFunctors, 0, Path, Cases0, Cases,
AddedImpurity, !DeepInfo),
@@ -1115,8 +1124,9 @@
ModuleInfo = !.DeepInfo ^ deep_module_info,
GoalFeatures = goal_info_get_features(GoalInfo0),
goal_info_remove_feature(feature_tailcall, GoalInfo0, GoalInfo1),
- make_impure(GoalInfo1, GoalInfoImpure),
- goal_info_set_mdprof_inst(goal_is_mdprof_inst, GoalInfoImpure, GoalInfo),
+ make_impure(GoalInfo1, GoalInfo2),
+ goal_info_set_mdprof_inst(goal_is_mdprof_inst, GoalInfo2,
+ MdprofInstGoalInfo),
% We need to make the call itself impure. If we didn't do so,
% then simplify could eliminate the goal (e.g. if it was a duplicate
@@ -1126,7 +1136,7 @@
% invariants of the deep profiling tree (which allows this field to be
% NULL only temporarily, between the prepare_for_{...}_call and the
% call port code).
- Goal1 = hlds_goal(GoalExpr0, GoalInfoImpure),
+ Goal1 = hlds_goal(GoalExpr0, GoalInfo2),
SiteNumCounter0 = !.DeepInfo ^ deep_site_num_counter,
counter.allocate(SiteNum, SiteNumCounter0, SiteNumCounter),
@@ -1267,7 +1277,8 @@
),
ExtraVars = list_to_set([MiddleCSD | SaveRestoreVars]),
WrappedGoalGoalInfo0 =
- goal_info_add_nonlocals_make_impure(GoalInfo, ExtraVars),
+ goal_info_add_nonlocals_make_impure(MdprofInstGoalInfo,
+ ExtraVars),
goal_info_set_mdprof_inst(goal_is_mdprof_inst,
WrappedGoalGoalInfo0, WrappedGoalGoalInfo),
@@ -1281,7 +1292,7 @@
FailGoalInfo0, FailGoalInfo),
FailGoal = hlds_goal(disj([]), FailGoalInfo),
- list.append(FailGoals, [FailGoal], FailGoalsAndFail),
+ FailGoalsAndFail = FailGoals ++ [FailGoal],
DisjGoalExpr = disj([
hlds_goal(
@@ -1303,7 +1314,7 @@
;
GoalExpr = conj(plain_conj, [SiteNumVarGoal, PrepareGoal, Goal2])
),
- Goal = hlds_goal(GoalExpr, GoalInfo).
+ Goal = hlds_goal(GoalExpr, MdprofInstGoalInfo).
:- pred deep_prof_transform_higher_order_call(globals::in, code_model::in,
hlds_goal::in, hlds_goal::out, deep_info::in, deep_info::out) is det.
@@ -1362,7 +1373,8 @@
goal_info_set_instmap_delta(EmptyDelta, ExtGoalInfo, NoBindExtGoalInfo),
FailGoalInfo0 = fail_goal_info,
- goal_info_set_mdprof_inst(goal_is_mdprof_inst, FailGoalInfo0, FailGoalInfo),
+ goal_info_set_mdprof_inst(goal_is_mdprof_inst,
+ FailGoalInfo0, FailGoalInfo),
FailGoal = hlds_goal(disj([]), FailGoalInfo),
RestoreFailGoalInfo0 = impure_unreachable_init_goal_info(ExtraNonLocals,
@@ -1620,7 +1632,7 @@
generate_csn_vector_cell(Length, InnerVars, CellVar, CellGoal,
!DeepInfo),
CSNVars = [CellVar | InnerVars],
- UnifyGoals = list.append(InnerGoals, [CellGoal])
+ UnifyGoals = InnerGoals ++ [CellGoal]
).
:- pred generate_csn_vector_cell(int::in, list(prog_var)::in,
@@ -2007,14 +2019,14 @@
coverage_points_map_list(CoveragePointsMap, CoveragePoints).
% Transform a goal for coverage profiling. This is the second pass of
- % the coverage profiling transformation. This is done in several steps.
+ % the coverage profiling transformation, and it consists of several steps.
%
- % If the first pass has been performed then relevant information is
- % collected from the goal_info structure.
+ % If the first pass has been performed then we collect the relevant
+ % information from the goal_info structure.
%
- % Step 1: Make a decision weather to insert a coverage point after this
+ % Step 1: Make a decision whether to insert a coverage point after this
% goal or not. This applies to may_fail multi and any coverage point
- % types only. Other coverage point types are handled seperatly.
+ % types only. Other coverage point types are handled seperately.
%
% Step 2: Determine if coverage information is known for goals that
% execute before this goal completes. This includes goals before this
@@ -2023,7 +2035,7 @@
%
% Step 3: Transform inner goals if this goal is non-atomic.
%
- % Step 4: Insert a coverage point after this goal if we decided to
+ % Step 4: Insert a coverage point after this goal if we decided to do so
% at step 1. This is done here after any inner goals have been
% transformed.
%
@@ -2037,7 +2049,7 @@
Detism = GoalInfo0 ^ goal_info_get_determinism,
% Depending on command line arguments first pass information may or may not
- % be available, if it is not avalible sensible defaults are assumed.
+ % be available, if it is not available, we assume semi-sensible defaults.
DPInfo = goal_info_get_dp_info(GoalInfo0),
DPInfo = dp_goal_info(IsMDProfInst, MaybeDPCoverageInfo),
(
@@ -2062,44 +2074,40 @@
% Consider inserting a coverage point after this goal to measure how
% many solutions it may have.
(
- IsMDProfInst = goal_is_not_mdprof_inst,
- (
- GoalTrivial = goal_is_nontrivial,
- (
- GoalHasPortCounts = goal_does_not_have_port_counts,
- (
- CoverageAfterKnown0 = coverage_after_unknown,
-
(
- % I havn't thought about parallel conjunctions here,
- % They should have the same declartive semantics as
- % plain conjunctions, and I beleive they arn't possible
- % where the first goal is anything other than
- % model_det, Only other models can affect the coverage
- % after the second goal. However I can't be sure the
- % implementation won't change.
- %
- % Because parallel conjunctions arn't common and this
- % is really only an optimiztion so I've only enabled it
- % for plain conjunctions.
-
+ % Never insert coverage points on goals that are part of the deep
+ % profiling instrumentation.
+ IsMDProfInst = goal_is_mdprof_inst
+ ;
+ % The goal itself has the counter we need; adding a second counter
+ % would be redundant.
+ GoalHasPortCounts = goal_has_port_counts
+ ;
+ % We already have execution counts for the program point after this
+ % goal; adding a counter would be redundant.
+ CoverageAfterKnown0 = coverage_after_known
+ ;
+ % We don't need to know the execution count of this goal, since
+ % it is too cheap to matter.
+ GoalTrivial = goal_is_trivial
+ ;
+ % Never insert coverage points after conjunctions; wait until
+ % the algorithm recurses to inside the conjunction and make a
+ % better decision about the last conjunct. This can reduce the
+ % number of coverage points inserted in some cases.
GoalExpr0 = conj(plain_conj, _)
- ->
- % Never insert coverage points after conjunctions, wait
- % until the algorithm recurses to inside the
- % conjunction and make a better decision about the last
- % conjunct. This can reduce the number of coverage
- % points inserted in some cases.
+ % We haven't yet thought about whether or not we should treat
+ % parallel conjunctions the same way.
+ )
+ ->
MaybeCPType = no
;
(
( Detism = detism_semi
; Detism = detism_cc_non
),
-
- CoverMayFail = !.Info ^ ci_coverage_profiling_opts ^
- cpo_may_fail,
+ CoverMayFail = !.Info ^ ci_coverage_profiling_opts ^ cpo_may_fail,
(
CoverMayFail = yes,
MaybeCPType = yes(cp_type_solns_may_fail)
@@ -2109,9 +2117,7 @@
)
;
Detism = detism_multi,
-
- CoverMulti = !.Info ^ ci_coverage_profiling_opts ^
- cpo_multi,
+ CoverMulti = !.Info ^ ci_coverage_profiling_opts ^ cpo_multi,
(
CoverMulti = yes,
MaybeCPType = yes(cp_type_solns_multi)
@@ -2121,9 +2127,7 @@
)
;
Detism = detism_non,
-
- CoverAny = !.Info ^ ci_coverage_profiling_opts ^
- cpo_any,
+ CoverAny = !.Info ^ ci_coverage_profiling_opts ^ cpo_any,
(
CoverAny = yes,
MaybeCPType = yes(cp_type_solns_any)
@@ -2132,42 +2136,23 @@
MaybeCPType = no
)
;
- % In this case we know that execution will always stop
- % at this goal, no coverage point is needed (or would
- % work).
( Detism = detism_erroneous
; Detism = detism_failure
),
+ % Execution cannot reach the point after this goal, so we need
+ % no coverage point.
MaybeCPType = no
;
- % This should never occur, as other coverage points
- % would have been inserted to ensure coverage is known
- % here, unless they are disabled. We don't insert a
- % coverage point here since we shouldn't have to.
( Detism = detism_det
; Detism = detism_cc_multi
),
+ % This should never occur, as coverage points should already have
+ % been inserted to ensure coverage is known here, unless the
+ % relevant kind of coverage points are disabled. We don't insert
+ % a coverage point here since we shouldn't have to.
+ % XXX In that case, why don't we call unexpected() here? -zs
MaybeCPType = no
)
- )
- ;
- CoverageAfterKnown0 = coverage_after_known,
- MaybeCPType = no
- )
- ;
- GoalHasPortCounts = goal_has_port_counts,
- MaybeCPType = no
- )
- ;
- GoalTrivial = goal_is_trivial,
- MaybeCPType = no
- )
- ;
- % Never insert coverage points on goals that are part of the deep
- % profiling instrumentation.
- %
- IsMDProfInst = goal_is_mdprof_inst,
- MaybeCPType = no
),
% Step 2.
@@ -2179,7 +2164,7 @@
;
MaybeCPType = no,
(
- % If the goal has a port count then coverage is known at the
+ % If the goal has a port count, then coverage is known at the
% point directy before this goal.
GoalHasPortCounts = goal_has_port_counts,
CoverageAfterKnown = coverage_after_known
@@ -2279,9 +2264,7 @@
AddedImpurityInner)
;
GoalExpr0 = shorthand(_),
- unexpected(this_file,
- "deep_profiling.coverage_prof_transform_goal: " ++
- "shorthand should have gone by now")
+ unexpected(this_file, "coverage_prof_second_pass_goal: shorthand")
),
add_impurity_if_needed(AddedImpurityInner, GoalInfo0, GoalInfo1),
Goal1 = hlds_goal(GoalExpr1, GoalInfo1),
@@ -2309,7 +2292,7 @@
% goal list represents the list of goals within a conjunction minus
% 'Pos' goals removed from the head.
%
- % This is done tail first as to take advantage of knoledge of goals after
+ % This is done tail first as to take advantage of knowledge of goals after
% the current goal within the conjunction.
%
:- pred coverage_prof_second_pass_conj(conj_type::in,
@@ -2317,8 +2300,7 @@
coverage_after_known::in, coverage_after_known::out,
proc_coverage_info::in, proc_coverage_info::out, bool::out) is det.
-coverage_prof_second_pass_conj(_, [], [], !CoverageAfterKnown,
- !Info, no).
+coverage_prof_second_pass_conj(_, [], [], !CoverageAfterKnown, !Info, no).
coverage_prof_second_pass_conj(ConjType, [Goal0 | Goals0], Goals,
CoverageAfterKnown0, NextCoverageAfterKnown, !Info, AddedImpurity) :-
coverage_prof_second_pass_conj(ConjType, Goals0, Goals1,
@@ -2339,7 +2321,7 @@
% disjunction. The list of goals represents the tail of the disjunction
% currently being transformed.
%
- % Disjuncts are also transformed in reverse order, as knoledge from
+ % Disjuncts are also transformed in reverse order, as knowledge from
% later disjuncts can be used to reduce the number of coverage points
% placed in earlier disjuncts.
%
@@ -2348,7 +2330,6 @@
proc_coverage_info::in, proc_coverage_info::out, bool::out) is det.
coverage_prof_second_pass_disj(_, [], [], !Info, no).
-
coverage_prof_second_pass_disj(DPInfo, [Goal0 | Goals0], [Goal | Goals], !Info,
AddedImpurity) :-
% Transform the tail of the disjunction.
@@ -2382,9 +2363,8 @@
coverage_after_known::in, coverage_after_known::out,
proc_coverage_info::in, proc_coverage_info::out, bool::out) is det.
-coverage_prof_second_pass_switchcase(_, _, [], [], _, coverage_after_known, !Info,
- no).
-
+coverage_prof_second_pass_switchcase(_, _, [], [], _, coverage_after_known,
+ !Info, no).
coverage_prof_second_pass_switchcase(DPInfo, SwitchCanFail,
[Case0 | Cases0], [Case | Cases], CoverageAfterSwitchKnown,
NextCoverageAfterKnown, !Info, AddedImpurity) :-
@@ -2477,16 +2457,7 @@
; ElseDetism = detism_cc_multi
),
- goal_info_get_maybe_dp_coverage_info(Then0 ^ hlds_goal_info) =
- ThenMaybeCoverageInfo,
- (
- ThenMaybeCoverageInfo = yes(dp_coverage_goal_info(_,
- ThenHasPortCounts))
- ;
- ThenMaybeCoverageInfo = no,
- ThenHasPortCounts = goal_does_not_have_port_counts
- ),
-
+ ThenHasPortCounts = goal_get_maybe_dp_has_port_counts(Then0),
(
ThenHasPortCounts = goal_does_not_have_port_counts,
@@ -2551,19 +2522,12 @@
% beginning of each branch,
CPOBranchIf = !.Info ^ ci_coverage_profiling_opts ^ cpo_branch_ite,
- CondMaybeDPCoverageInfo = goal_info_get_maybe_dp_coverage_info(
- Cond0 ^ hlds_goal_info),
- (
- CondMaybeDPCoverageInfo =
- yes(dp_coverage_goal_info(_, CondHasPortCounts))
- ;
- CondMaybeDPCoverageInfo = no,
- CondHasPortCounts = goal_does_not_have_port_counts
- ),
+ CondHasPortCounts = goal_get_maybe_dp_has_port_counts(Cond0),
DPInfo = dp_goal_info(IsMDProfInst, _),
(
CPOBranchIf = yes,
CondHasPortCounts = goal_does_not_have_port_counts,
+ % XXX This test looks to be a bug; I think it should be reversed. -zs
IsMDProfInst = goal_is_mdprof_inst
->
(
@@ -2573,7 +2537,6 @@
cp_type_branch_arm))
;
CoverageBeforeThenKnown1 = coverage_after_known,
-
InsertCPThen = no
),
(
@@ -2583,7 +2546,6 @@
cp_type_branch_arm))
;
CoverageBeforeElseKnown1 = coverage_after_known,
-
InsertCPElse = no
)
;
@@ -2639,6 +2601,18 @@
MaybeCoverageInfo = no
).
+:- func goal_get_maybe_dp_has_port_counts(hlds_goal) = goal_has_port_counts.
+
+goal_get_maybe_dp_has_port_counts(Goal) = HasPortCounts :-
+ Goal = hlds_goal(_, GoalInfo),
+ MaybeCoverageInfo = goal_info_get_maybe_dp_coverage_info(GoalInfo),
+ (
+ MaybeCoverageInfo = yes(dp_coverage_goal_info(_, HasPortCounts))
+ ;
+ MaybeCoverageInfo = no,
+ HasPortCounts = goal_does_not_have_port_counts
+ ).
+
% Set the 'goal_is_mdprof_inst' field in the goal_dp_info structure
% in the given goal info structure.
%
@@ -2664,9 +2638,7 @@
coverage_after_known::in, coverage_after_known::out,
proc_coverage_info::in, proc_coverage_info::out, bool::out) is det.
-maybe_insert_coverage_point_before(no, !Goal, !CoverageAfterKnown,
- !Info, no).
-
+maybe_insert_coverage_point_before(no, !Goal, !CoverageAfterKnown, !Info, no).
maybe_insert_coverage_point_before(yes(CPInfo), !Goal,
_, coverage_after_known, !Info, yes) :-
insert_coverage_point_before(CPInfo, !Goal, !Info).
@@ -2680,9 +2652,7 @@
insert_coverage_point_before(CPInfo, !Goal, !Info) :-
make_coverage_point(CPInfo, CPGoals, !Info),
- (
- !.Goal = hlds_goal(conj(plain_conj, InnerGoals), _)
- ->
+ ( !.Goal = hlds_goal(conj(plain_conj, InnerGoals), _) ->
Goals = CPGoals ++ InnerGoals
;
Goals = CPGoals ++ [!.Goal]
@@ -2700,6 +2670,8 @@
% this is at the beginning of the branch since it's used for the main
% pass which is done in reverse.
%
+ % XXX That documentation does not make sense.
+ %
:- pred coverage_after_known_branch(coverage_after_known::in,
coverage_after_known::in, coverage_after_known::out) is det.
@@ -2711,7 +2683,7 @@
coverage_after_unknown).
% Create a coverage info struture, initializing some values to sensible
- % defaults..
+ % defaults.
%
:- func init_proc_coverage_info(var_info, module_info, pred_proc_id,
maybe(deep_recursion_info), coverage_profiling_options) =
@@ -2722,7 +2694,7 @@
CoverageInfo = proc_coverage_info(map.init, counter.init(0), VarInfo,
ModuleInfo, PredProcId, MaybeRecInfo, CoverageProfilingOptions).
- % Boolean or for goal_trivial data type.
+ % Boolean AND for the goal_trivial data type.
%
:- pred goal_trivial_and(goal_trivial::in, goal_trivial::in,
goal_trivial::out) is det.
@@ -2750,9 +2722,10 @@
HasPortCounts = goal_does_not_have_port_counts
).
- % Given the a goal and whether port counts are availible before it
- % determine if port counts can be used to determine how often execution
- % reaches the poind imediatly after this goal.
+ % Given a goal, whether it has its own port counts and whether port counts
+ % are available immediately before it, determine if either set of port
+ % counts allows us to determine how often execution reaches the point
+ % immediately after the goal.
%
:- pred has_port_counts_after(hlds_goal::in, goal_has_port_counts::in,
goal_has_port_counts::in, goal_has_port_counts::out) is det.
@@ -2772,7 +2745,7 @@
% then they can be used to determine how often execution reaches the
% point after this goal.
- Detism = Goal ^ hlds_goal_info ^ goal_info_get_determinism,
+ Detism = goal_info_get_determinism(Goal ^ hlds_goal_info),
has_port_counts_if_det(Detism, PCBefore, PC)
).
@@ -2796,14 +2769,14 @@
% Used to gather some information about goals before the coverage
% transformation.
%
+ % XXX Document *what* information this pass gathers.
+ %
:- pred coverage_prof_first_pass(coverage_profiling_options::in, hlds_goal::in,
hlds_goal::out, goal_has_port_counts::in, dp_coverage_goal_info::out)
is det.
-coverage_prof_first_pass(CPOptions, Goal0, hlds_goal(GoalExpr, GoalInfo),
- HasPortCountsBefore, Info) :-
+coverage_prof_first_pass(CPOptions, Goal0, Goal, HasPortCountsBefore, Info) :-
Goal0 = hlds_goal(GoalExpr0, GoalInfo0),
-
(
% XXX: Not all call goals have associated call sites, therefore not all
% of these will have port counts. See above in the deep_profiling
@@ -2814,6 +2787,9 @@
% naive assumption in the second pass is fixed (even when this first
% pass is not used).
%
+ % XXX I don't understand this comment. Are you talking about builtin
+ % calls? Calls to the profiling primitives themselves? What is the
+ % naive assumption, and why is it a problem? -zs
( GoalExpr0 = plain_call(_, _, _, _, _, _)
; GoalExpr0 = generic_call(_, _, _, _)
; GoalExpr0 = call_foreign_proc(_, _, _, _, _, _, _)
@@ -2904,9 +2880,7 @@
HasPortCountsDirect)
;
GoalExpr0 = shorthand(_),
- unexpected(this_file,
- "deep_profiling.goal_is_nontrivial: " ++
- "shorthand should have gone by now")
+ unexpected(this_file, "coverage_prof_first_pass: shorthand")
),
(
@@ -2936,7 +2910,8 @@
MaybeDPInfo0 = no,
error("coverage_prof_first_pass: goal_dp_info not present")
),
- goal_info_set_maybe_dp_info(yes(DPInfo), GoalInfo0, GoalInfo).
+ goal_info_set_maybe_dp_info(yes(DPInfo), GoalInfo0, GoalInfo),
+ Goal = hlds_goal(GoalExpr, GoalInfo).
% Combine information about goals within a conjunction
%
@@ -2950,7 +2925,7 @@
dp_coverage_goal_info(TrivialGoal, HasPortCounts)),
goal_trivial_and(TrivialAcc, TrivialGoal, Trivial).
- % Combine information about goals within a disjunction
+ % Combine information about goals within a disjunction.
%
% A portcount may be available to the goal executed when first entering a
% disjunction. However it is impractical to determine if any disjuncts
@@ -2962,7 +2937,6 @@
goal_has_port_counts::in, goal_has_port_counts::out) is det.
coverage_prof_first_pass_disj(_, [], [], goal_is_trivial, !HasPortCounts).
-
coverage_prof_first_pass_disj(CPOptions, [Goal0 | Goals0], [Goal | Goals],
Trivial, HasPortCountsBefore, HasPortCounts) :-
coverage_prof_first_pass(CPOptions, Goal0, Goal, HasPortCountsBefore,
@@ -2981,8 +2955,8 @@
list(case)::in, list(case)::out, goal_trivial::out,
goal_has_port_counts::out) is det.
-coverage_prof_first_pass_switchcase(_, [], [], goal_is_trivial,
- goal_has_port_counts).
+coverage_prof_first_pass_switchcase(_, [], [],
+ goal_is_trivial, goal_has_port_counts).
coverage_prof_first_pass_switchcase(CPOptions,
[Case0 | Cases0], [Case | Cases], Trivial, HasPortCounts) :-
Case0 = case(FirstFunctor, LaterFunctors, Goal0),
@@ -3062,10 +3036,11 @@
to_sorted_assoc_list(Map, AssocList),
values(AssocList, List).
- % Retrive the pred and proc ids from either the deep_mabye_rec_info or
+ % Retrieve the pred and proc ids from either the deep_maybe_rec_info or
% deep_pred_proc_id fields of a deep_info structure.
%
-:- pred pred_proc_id(proc_coverage_info::in, pred_id::out, proc_id::out) is det.
+:- pred pred_proc_id(proc_coverage_info::in, pred_id::out, proc_id::out)
+ is det.
pred_proc_id(CoverageInfo, PredId, ProcId) :-
MaybeRecInfo = CoverageInfo ^ ci_maybe_rec_info,
Index: compiler/hlds_goal.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/hlds_goal.m,v
retrieving revision 1.197
diff -u -b -r1.197 hlds_goal.m
--- compiler/hlds_goal.m 14 Sep 2008 03:52:53 -0000 1.197
+++ compiler/hlds_goal.m 16 Sep 2008 08:37:08 -0000
@@ -1073,7 +1073,7 @@
:- type missed_message == string.
- % Goal Information used by the deep profiler.
+ % Information about the goal used by the deep profiler.
%
:- type dp_goal_info
---> dp_goal_info(
@@ -1081,15 +1081,14 @@
maybe(dp_coverage_goal_info)
).
- % Descrbe weather this goal has been introduced because as instrumentation
- % used by the deep profiler.
+ % Was this goal introduced by the deep profiler as instrumentation code?
%
:- type goal_is_mdprof_inst
---> goal_is_mdprof_inst
; goal_is_not_mdprof_inst.
- % Information used by the deep profilier to preform coverage profiling.
- % Predicates to operate on these types exist in deep_profiling.m
+ % Information used by the deep profiler to perform coverage profiling.
+ % The predicates that operate on these types are in deep_profiling.m.
%
:- type dp_coverage_goal_info
---> dp_coverage_goal_info(
@@ -1105,7 +1104,6 @@
---> goal_has_port_counts
; goal_does_not_have_port_counts.
-
:- pred goal_info_init(hlds_goal_info::out) is det.
:- pred goal_info_init(prog_context::in, hlds_goal_info::out) is det.
:- pred goal_info_init(set(prog_var)::in, instmap_delta::in, determinism::in,
Index: compiler/hlds_out.m
===================================================================
RCS file: /home/mercury/mercury1/repository/mercury/compiler/hlds_out.m,v
retrieving revision 1.456
diff -u -b -r1.456 hlds_out.m
--- compiler/hlds_out.m 14 Sep 2008 03:52:53 -0000 1.456
+++ compiler/hlds_out.m 16 Sep 2008 08:55:39 -0000
@@ -1444,25 +1444,32 @@
( string.contains_char(Verbose, 'E') ->
MaybeDPInfo = goal_info_get_maybe_dp_info(GoalInfo),
(
- MaybeDPInfo = yes(dp_goal_info(_, MaybeDPCoverageInfo)),
+ MaybeDPInfo = yes(dp_goal_info(MdprofInst, MaybeDPCoverageInfo)),
(
- MaybeDPCoverageInfo = yes(dp_coverage_goal_info(Trivial,
- HasPortCounts)),
+ MdprofInst = goal_is_mdprof_inst,
+ write_indent(Indent, !IO),
+ io.write_string("% mdprof instrumentation\n", !IO)
+ ;
+ MdprofInst = goal_is_not_mdprof_inst
+ ),
+ (
+ MaybeDPCoverageInfo = yes(CoverageInfo),
+ CoverageInfo = dp_coverage_goal_info(IsTrivial, HasPortCounts),
write_indent(Indent, !IO),
(
- Trivial = goal_is_trivial,
- io.write_string("% Goal is trivial, ", !IO)
+ IsTrivial = goal_is_trivial,
+ io.write_string("% trivial goal\n", !IO)
;
- Trivial = goal_is_nontrivial,
- io.write_string("% Goal is non-trivial, ", !IO)
+ IsTrivial = goal_is_nontrivial,
+ io.write_string("% nontrivial goal\n", !IO)
),
+ write_indent(Indent, !IO),
(
HasPortCounts = goal_has_port_counts,
- io.write_string("Goal has port counts avalible.\n", !IO)
+ io.write_string("% has port counts\n", !IO)
;
HasPortCounts = goal_does_not_have_port_counts,
- io.write_string("Goal does not have port counts avalible.\n",
- !IO)
+ io.write_string("% does not have port counts\n", !IO)
)
;
MaybeDPCoverageInfo = no
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/base64
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/fixed
cvs diff: Diffing extras/gator
cvs diff: Diffing extras/gator/generations
cvs diff: Diffing extras/gator/generations/1
cvs diff: Diffing extras/graphics
cvs diff: Diffing extras/graphics/easyx
cvs diff: Diffing extras/graphics/easyx/samples
cvs diff: Diffing extras/graphics/mercury_allegro
cvs diff: Diffing extras/graphics/mercury_allegro/examples
cvs diff: Diffing extras/graphics/mercury_allegro/samples
cvs diff: Diffing extras/graphics/mercury_allegro/samples/demo
cvs diff: Diffing extras/graphics/mercury_allegro/samples/mandel
cvs diff: Diffing extras/graphics/mercury_allegro/samples/pendulum2
cvs diff: Diffing extras/graphics/mercury_allegro/samples/speed
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/log4m
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/mopenssl
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/net
cvs diff: Diffing extras/odbc
cvs diff: Diffing extras/posix
cvs diff: Diffing extras/posix/samples
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/trailed_update
cvs diff: Diffing extras/trailed_update/samples
cvs diff: Diffing extras/trailed_update/tests
cvs diff: Diffing extras/windows_installer_generator
cvs diff: Diffing extras/windows_installer_generator/sample
cvs diff: Diffing extras/windows_installer_generator/sample/images
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/c_interface/standalone_c
cvs diff: Diffing samples/diff
cvs diff: Diffing samples/muz
cvs diff: Diffing samples/rot13
cvs diff: Diffing samples/solutions
cvs diff: Diffing samples/solver_types
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 ssdb
cvs diff: Diffing tests
cvs diff: Diffing tests/analysis
cvs diff: Diffing tests/analysis/ctgc
cvs diff: Diffing tests/analysis/excp
cvs diff: Diffing tests/analysis/ext
cvs diff: Diffing tests/analysis/sharing
cvs diff: Diffing tests/analysis/table
cvs diff: Diffing tests/analysis/trail
cvs diff: Diffing tests/analysis/unused_args
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/par_conj
cvs diff: Diffing tests/recompilation
cvs diff: Diffing tests/tabling
cvs diff: Diffing tests/term
cvs diff: Diffing tests/trailing
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 messages to: mercury-reviews at csse.unimelb.edu.au
Administrative Queries: owner-mercury-reviews at csse.unimelb.edu.au
Subscriptions: mercury-reviews-request at csse.unimelb.edu.au
--------------------------------------------------------------------------
More information about the reviews
mailing list