for review: better names for lambda goals
Thomas Charles CONWAY
conway at cs.mu.oz.au
Tue Aug 26 16:07:50 AEST 1997
Hi
Fergus/Pete Ross, can one of you please review this.
--
ZZ:wq!
^X^C
Thomas Conway conway at cs.mu.oz.au
AD DEUM ET VINUM Every sword has two edges.
Profiling code with lots of lambda goals was painful, because the names
of the predicates contained no information about which piece of the source
they correspond to. This change corrects this problem by enabling the
profiler to produce output such as:
... 0.00 0.00 <pred/func goal from lp:'pivot', line 362> [10]
... 0.00 0.00 <pred/func goal from lp:'pivot', line 356> [11]
... 0.00 0.00 <pred/func goal from lp:'simplex', line 262> [12]
compiler/lambda.m:
compiler/polymorphism.m:
construct more meaningful predicate names for lambda predicates.
this required adding the name of the predicate that contained the
lambda goal to the info structures that gets threaded through
these modules.
profiler/demangle.m:
demangle the names for lambda goals.
cvs diff: Diffing .
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/include
cvs diff: Diffing boehm_gc/include/private
cvs diff: Diffing bytecode
cvs diff: Diffing compiler
Index: compiler/lambda.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/lambda.m,v
retrieving revision 1.30
diff -u -r1.30 lambda.m
--- lambda.m 1997/07/27 15:00:44 1.30
+++ lambda.m 1997/08/25 05:36:50
@@ -41,11 +41,11 @@
:- pred lambda__process_pred(pred_id, module_info, module_info).
:- mode lambda__process_pred(in, in, out) is det.
-:- pred lambda__transform_lambda(pred_or_func, list(var), list(mode),
+:- pred lambda__transform_lambda(pred_or_func, string, list(var), list(mode),
determinism, set(var), hlds_goal, unification,
varset, map(var, type), tvarset, map(tvar, var), module_info,
unify_rhs, unification, module_info).
-:- mode lambda__transform_lambda(in, in, in, in, in, in, in, in, in, in, in,
+:- mode lambda__transform_lambda(in, in, in, in, in, in, in, in, in, in, in, in,
in, out, out, out) is det.
% Permute the list of variables so that inputs come before outputs.
@@ -69,6 +69,8 @@
map(var, type), % from the proc_info
tvarset, % from the proc_info
map(tvar, var), % from the proc_info (typeinfos)
+ pred_or_func,
+ string, % pred/func name
module_info
).
@@ -115,6 +117,8 @@
lambda__process_proc_2(ProcInfo0, PredInfo0, ModuleInfo0,
ProcInfo, PredInfo, ModuleInfo) :-
% grab the appropriate fields from the pred_info and proc_info
+ pred_info_name(PredInfo0, PredName),
+ pred_info_get_is_pred_or_func(PredInfo0, PredOrFunc),
pred_info_typevarset(PredInfo0, TypeVarSet0),
proc_info_variables(ProcInfo0, VarSet0),
proc_info_vartypes(ProcInfo0, VarTypes0),
@@ -123,9 +127,11 @@
% process the goal
Info0 = lambda_info(VarSet0, VarTypes0, TypeVarSet0, TVarMap0,
+ PredOrFunc, PredName,
ModuleInfo0),
lambda__process_goal(Goal0, Goal, Info0, Info),
Info = lambda_info(VarSet, VarTypes, TypeVarSet, TVarMap,
+ _, _,
ModuleInfo),
% set the new values of the fields in proc_info and pred_info
@@ -219,16 +225,18 @@
lambda__process_lambda(PredOrFunc, Vars, Modes, Det, OrigNonLocals0, LambdaGoal,
Unification0, Functor, Unification, LambdaInfo0, LambdaInfo) :-
LambdaInfo0 = lambda_info(VarSet, VarTypes, TVarSet, TVarMap,
- ModuleInfo0),
- lambda__transform_lambda(PredOrFunc, Vars, Modes, Det, OrigNonLocals0,
- LambdaGoal, Unification0, VarSet, VarTypes, TVarSet, TVarMap,
- ModuleInfo0, Functor, Unification, ModuleInfo),
+ POF, PredName, ModuleInfo0),
+ lambda__transform_lambda(PredOrFunc, PredName, Vars, Modes, Det,
+ OrigNonLocals0, LambdaGoal, Unification0, VarSet, VarTypes,
+ TVarSet, TVarMap, ModuleInfo0, Functor,
+ Unification, ModuleInfo),
LambdaInfo = lambda_info(VarSet, VarTypes, TVarSet, TVarMap,
- ModuleInfo).
+ POF, PredName, ModuleInfo).
-lambda__transform_lambda(PredOrFunc, Vars, Modes, Detism, OrigNonLocals0,
- LambdaGoal, Unification0, VarSet, VarTypes, TVarSet, TVarMap,
- ModuleInfo0, Functor, Unification, ModuleInfo) :-
+lambda__transform_lambda(PredOrFunc, OrigPredName, Vars, Modes, Detism,
+ OrigNonLocals0, LambdaGoal, Unification0, VarSet, VarTypes,
+ TVarSet, TVarMap, ModuleInfo0, Functor,
+ Unification, ModuleInfo) :-
(
Unification0 = construct(Var0, _, _, UniModes0)
->
@@ -308,10 +316,10 @@
module_info_name(ModuleInfo0, ModuleName),
module_info_next_lambda_count(ModuleInfo0, LambdaCount,
ModuleInfo1),
- string__int_to_string(LambdaCount, LambdaCountStr),
- string__append("__LambdaGoal__", LambdaCountStr, PName0),
- string__append(ModuleName, PName0, PName),
- PredName = qualified(ModuleName, PName),
+ goal_info_get_context(LambdaGoalInfo, OrigContext),
+ term__context_line(OrigContext, OrigLine),
+ make_lambda_name(ModuleName, PredOrFunc, OrigPredName,
+ OrigLine, LambdaCount, PredName),
goal_info_get_context(LambdaGoalInfo, LambdaContext),
% the TVarSet is a superset of what it really ought be,
% but that shouldn't matter
@@ -369,6 +377,21 @@
Functor = functor(cons(PredName, NumArgVars), ArgVars),
ConsId = pred_const(PredId, ProcId),
Unification = construct(Var, ConsId, ArgVars, UniModes).
+
+:- pred make_lambda_name(string, pred_or_func, string, int, int, sym_name).
+:- mode make_lambda_name(in, in, in, in, in, out) is det.
+
+make_lambda_name(ModuleName, PredOrFunc, PredName, Line, Counter, SymName) :-
+ (
+ PredOrFunc = predicate,
+ PFS = "pred"
+ ;
+ PredOrFunc = function,
+ PFS = "func"
+ ),
+ string__format("IntroducedFrom__%s__%s__%d__%d",
+ [s(PFS), s(PredName), i(Line), i(Counter)], Name),
+ SymName = qualified(ModuleName, Name).
:- pred lambda__uni_modes_to_modes(list(uni_mode), list(mode)).
:- mode lambda__uni_modes_to_modes(in, out) is det.
Index: compiler/polymorphism.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/compiler/polymorphism.m,v
retrieving revision 1.115
diff -u -r1.115 polymorphism.m
--- polymorphism.m 1997/08/09 05:01:28 1.115
+++ polymorphism.m 1997/08/25 05:33:58
@@ -287,6 +287,7 @@
map(tvar, var), % specifies the type_info var
% for each of the pred's type
% parameters
+ string, % pred name
module_info
).
@@ -299,6 +300,7 @@
% grab the appropriate fields from the pred_info and proc_info
pred_info_arg_types(PredInfo0, ArgTypeVarSet, ArgTypes),
pred_info_typevarset(PredInfo0, TypeVarSet0),
+ pred_info_name(PredInfo0, PredName),
proc_info_headvars(ProcInfo0, HeadVars0),
proc_info_variables(ProcInfo0, VarSet0),
proc_info_vartypes(ProcInfo0, VarTypes0),
@@ -321,10 +323,11 @@
map__from_corresponding_lists(HeadTypeVars, ExtraHeadVars,
TypeInfoMap0),
Info0 = poly_info(VarSet1, VarTypes1, TypeVarSet0,
- TypeInfoMap0, ModuleInfo0),
+ TypeInfoMap0, PredName, ModuleInfo0),
polymorphism__process_goal(Goal0, Goal1, Info0, Info1),
polymorphism__fixup_quantification(Goal1, Goal, Info1, Info),
- Info = poly_info(VarSet, VarTypes, TypeVarSet, TypeInfoMap, ModuleInfo),
+ Info = poly_info(VarSet, VarTypes, TypeVarSet, TypeInfoMap, _PredName,
+ ModuleInfo),
% set the new values of the fields in proc_info and pred_info
proc_info_set_headvars(ProcInfo0, HeadVars, ProcInfo1),
@@ -365,7 +368,7 @@
{ list__length(ArgVars0, Arity) },
{ special_pred_name_arity(SpecialPredId, PredName0,
MangledPredName, Arity) },
- =(poly_info(_, VarTypes, _, _TypeInfoMap, ModuleInfo)),
+ =(poly_info(_, VarTypes, _, _TypeInfoMap, _PN, ModuleInfo)),
{ special_pred_get_type(MangledPredName, ArgVars0, MainVar) },
{ map__lookup(VarTypes, MainVar, Type) },
{ Type \= term__variable(_) },
@@ -401,7 +404,7 @@
{ Unification = complicated_unify(UniMode, CanFail) },
{ Y = var(YVar) }
->
- =(poly_info(_, VarTypes, _, TypeInfoMap, ModuleInfo)),
+ =(poly_info(_, VarTypes, _, TypeInfoMap, _PName, ModuleInfo)),
{ map__lookup(VarTypes, XVar, Type) },
( { Type = term__variable(TypeVar) } ->
% Convert polymorphic unifications into calls to
@@ -485,8 +488,8 @@
{ goal_info_get_nonlocals(GoalInfo0, OrigNonLocals) },
polymorphism__process_goal(LambdaGoal0, LambdaGoal1),
polymorphism__fixup_quantification(LambdaGoal1, LambdaGoal),
- polymorphism__process_lambda(PredOrFunc, Vars, Modes, Det,
- OrigNonLocals, LambdaGoal, Unification,
+ polymorphism__process_lambda(PredOrFunc, Vars, Modes,
+ Det, OrigNonLocals, LambdaGoal, Unification,
Y1, Unification1),
{ Goal = unify(XVar, Y1, Mode, Unification1, Context)
- GoalInfo }
@@ -534,7 +537,7 @@
% so that the c_code can refer to the type_info variable
% for type T as `TypeInfo_for_T'.
%
- =(poly_info(_, _, _, _, ModuleInfo)),
+ =(poly_info(_, _, _, _, _, ModuleInfo)),
{ module_info_pred_info(ModuleInfo, PredId, PredInfo) },
{ pred_info_arg_types(PredInfo, PredTypeVarSet, PredArgTypes) },
{ term__vars_list(PredArgTypes, PredTypeVars0) },
@@ -610,7 +613,7 @@
polymorphism__process_call(PredId, _ProcId, ArgVars0, ArgVars,
ExtraVars, ExtraGoals, Info0, Info) :-
Info0 = poly_info(VarSet0, VarTypes0, TypeVarSet0,
- TypeInfoMap0, ModuleInfo),
+ TypeInfoMap0, PredName, ModuleInfo),
module_info_pred_info(ModuleInfo, PredId, PredInfo),
pred_info_arg_types(PredInfo, PredTypeVarSet, PredArgTypes0),
% rename apart
@@ -642,7 +645,7 @@
VarTypes),
list__append(ExtraVars, ArgVars0, ArgVars),
Info = poly_info(VarSet, VarTypes, TypeVarSet,
- TypeInfoMap, ModuleInfo)
+ TypeInfoMap, PredName, ModuleInfo)
).
:- pred polymorphism__fixup_quantification(hlds_goal, hlds_goal,
@@ -658,7 +661,7 @@
polymorphism__fixup_quantification(Goal0, Goal, Info0, Info) :-
Info0 = poly_info(VarSet0, VarTypes0, TypeVarSet, TypeVarMap,
- ModuleInfo),
+ PredName, ModuleInfo),
( map__is_empty(TypeVarMap) ->
Info = Info0,
Goal = Goal0
@@ -682,11 +685,11 @@
implicitly_quantify_goal(Goal0, VarSet0, VarTypes0,
OutsideVars, Goal, VarSet, VarTypes, _Warnings),
Info = poly_info(VarSet, VarTypes, TypeVarSet, TypeVarMap,
- ModuleInfo)
+ PredName, ModuleInfo)
).
-:- pred polymorphism__process_lambda(pred_or_func, list(var), list(mode),
- determinism, set(var), hlds_goal, unification,
+:- pred polymorphism__process_lambda(pred_or_func, list(var),
+ list(mode), determinism, set(var), hlds_goal, unification,
unify_rhs, unification, poly_info, poly_info).
:- mode polymorphism__process_lambda(in, in, in, in, in, in, in, out, out,
in, out) is det.
@@ -694,11 +697,14 @@
polymorphism__process_lambda(PredOrFunc, Vars, Modes, Det, OrigNonLocals,
LambdaGoal, Unification0, Functor, Unification,
PolyInfo0, PolyInfo) :-
- PolyInfo0 = poly_info(VarSet, VarTypes, TVarSet, TVarMap, ModuleInfo0),
- lambda__transform_lambda(PredOrFunc, Vars, Modes, Det, OrigNonLocals,
- LambdaGoal, Unification0, VarSet, VarTypes, TVarSet, TVarMap,
- ModuleInfo0, Functor, Unification, ModuleInfo),
- PolyInfo = poly_info(VarSet, VarTypes, TVarSet, TVarMap, ModuleInfo).
+ PolyInfo0 = poly_info(VarSet, VarTypes, TVarSet, TVarMap, PredName,
+ ModuleInfo0),
+ lambda__transform_lambda(PredOrFunc, PredName, Vars, Modes, Det,
+ OrigNonLocals, LambdaGoal, Unification0, VarSet, VarTypes,
+ TVarSet, TVarMap, ModuleInfo0, Functor,
+ Unification, ModuleInfo),
+ PolyInfo = poly_info(VarSet, VarTypes, TVarSet, TVarMap, PredName,
+ ModuleInfo).
%---------------------------------------------------------------------------%
@@ -1238,14 +1244,14 @@
:- mode polymorphism__get_module_info(out, in, out) is det.
polymorphism__get_module_info(ModuleInfo, PolyInfo, PolyInfo) :-
- PolyInfo = poly_info(_, _, _, _, ModuleInfo).
+ PolyInfo = poly_info(_, _, _, _, _, ModuleInfo).
:- pred polymorphism__set_module_info(module_info, poly_info, poly_info).
:- mode polymorphism__set_module_info(in, in, out) is det.
polymorphism__set_module_info(ModuleInfo, PolyInfo0, PolyInfo) :-
- PolyInfo0 = poly_info(A, B, C, D, _),
- PolyInfo = poly_info(A, B, C, D, ModuleInfo).
+ PolyInfo0 = poly_info(A, B, C, D, E, _),
+ PolyInfo = poly_info(A, B, C, D, E, ModuleInfo).
%---------------------------------------------------------------------------%
%---------------------------------------------------------------------------%
cvs diff: Diffing compiler/notes
cvs diff: Diffing doc
cvs diff: Diffing extras
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/graphics
cvs diff: Diffing extras/graphics/Togl-1.2
cvs diff: Diffing extras/graphics/samples
cvs diff: Diffing extras/graphics/samples/calc
cvs diff: Diffing extras/graphics/samples/maze
cvs diff: Diffing library
cvs diff: Diffing lp_solve
cvs diff: Diffing lp_solve/lp_examples
cvs diff: Diffing profiler
Index: profiler/demangle.m
===================================================================
RCS file: /home/staff/zs/imp/mercury/profiler/demangle.m,v
retrieving revision 1.1
diff -u -r1.1 demangle.m
--- demangle.m 1997/07/26 11:41:48 1.1
+++ demangle.m 1997/08/25 22:26:00
@@ -29,7 +29,8 @@
:- implementation.
:- import_module int, list, char, std_util, bool, require.
-:- type pred_category ---> index ; unify ; compare ; ordinary.
+:- type pred_category ---> index ; unify ; compare ; ordinary ;
+ lambda(int).
:- type data_category ---> common ; info ; layout ; functors.
demangle(MangledName, Name) :-
@@ -113,17 +114,17 @@
% skip past the prefix.
%
( remove_prefix("__Unify__") ->
- { Category = unify }
+ { Category0 = unify }
; remove_prefix("__Compare__") ->
- { Category = compare },
+ { Category0 = compare },
% there should only be one mode for compare/3 preds
{ ModeNum0 = 0 }
; remove_prefix("__Index__") ->
- { Category = index },
+ { Category0 = index },
% there should only be one mode for index/2 preds
{ ModeNum0 = 0 }
;
- { Category = ordinary }
+ { Category0 = ordinary }
),
%
@@ -173,29 +174,50 @@
% Separate the module name from the type name for the compiler
% generated predicates.
%
- ( { Category \= ordinary } ->
+ ( { Category0 \= ordinary } ->
remove_prefix("_"),
remove_maybe_module_prefix(MaybeModule),
{ MaybeModule \= yes("") }
;
remove_maybe_module_prefix(MaybeModule)
),
-
+
%
% Make sure special predicates with unused_args
% are reported correctly.
%
- ( { UnusedArgs = yes, Category \= ordinary } ->
+ ( { UnusedArgs = yes, Category0 \= ordinary } ->
remove_trailing_int(Arity)
;
{ true }
),
%
+ % Now we need to look at the pred name and see if it is an
+ % introduced lambda predicate.
+ %
+
+ =(PredName0),
+
+ ( remove_prefix("IntroducedFrom__") ->
+ ( remove_prefix("pred__") ->
+ []
+ ; remove_prefix("func__")
+ ),
+ remove_maybe_module_prefix(MPredName),
+ { MPredName = yes(PredName) },
+ remove_int(Line),
+ { Category = lambda(Line) }
+ ;
+ { Category = Category0 },
+ { PredName = PredName0 }
+ ),
+
+
+ %
% Now, finally, we can construct the demangled symbol name
%
- =(PredName),
{ format_proc(Category, MaybeModule, PredOrFunc, PredName,
Arity, ModeNum, HigherOrder, UnusedArgs, MaybeInternalLabelNum,
Parts, []) },
@@ -229,6 +251,10 @@
string__format("%s %s/%d mode %d",
[s(PredOrFunc), s(QualifiedName), i(Arity), i(ModeNum)],
MainPart)
+ ;
+ Category = lambda(Line),
+ string__format("pred/func goal from %s, line %d",
+ [s(QualifiedName), i(Line)], MainPart)
},
[MainPart],
( { HigherOrder = yes } ->
cvs diff: Diffing runtime
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/simpler_c_calls_mercury
cvs diff: Diffing samples/c_interface/simpler_cplusplus_calls_mercury
cvs diff: Diffing samples/diff
cvs diff: Diffing scripts
cvs diff: Diffing tools
cvs diff: Diffing trial
cvs diff: Diffing util
More information about the developers
mailing list