mirror of
https://github.com/Mercury-Language/mercury.git
synced 2025-12-06 07:49:02 +00:00
cbb7d8613b
library/LIB_FLAGS.in:
mfilterjavac/MFILTERJAVAC_FLAGS.in:
profiler/PROF_FLAGS.in:
slice/SLICE_FLAGS.in:
ssdb/SSDB_FLAGS.in:
Specify --warn-inconsistent-pred-order-clauses as a default flag
in these directories as well.
library/string.m:
Reorder code to make this module compile cleanly with
--warn-inconsistent-pred-order-clauses.
Don't export base_string_to_int_underscore to lexer.m, since
lexer.m does not use it anymore, and neither does anything else.
(The export was not publicly documented.)
library/benchmarking.m:
library/bitmap.m:
library/builtin.m:
library/map.m:
library/profiling_builtin.m:
library/rbtree.m:
library/table_builtin.m:
library/uint.m:
profiler/globals.m:
profiler/options.m:
profiler/prof_info.m:
slice/mdice.m:
slice/mslice.m:
slice/mtc_diff.m:
slice/mtc_union.m:
ssdb/ssdb.m:
Reorder code to make these modules compile cleanly with
--warn-inconsistent-pred-order-clauses.
library/Mercury.options:
Specify --no-warn-inconsistent-pred-order-clauses for the modules
that would still get warnings without this option.
411 lines
15 KiB
Mathematica
411 lines
15 KiB
Mathematica
%---------------------------------------------------------------------------%
|
|
% vim: ft=mercury ts=4 sw=4 et
|
|
%---------------------------------------------------------------------------%
|
|
% Copyright (C) 1995-1997, 2004-2006, 2011 The University of Melbourne.
|
|
% This file may only be copied under the terms of the GNU General
|
|
% Public License - see the file COPYING in the Mercury distribution.
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% File: prof_info.m
|
|
% Main author: petdr.
|
|
%
|
|
% Declare the main data structures for mercury.profile and their access
|
|
% predicates, the actual types are exported as well. This is because some
|
|
% predicates need to access entire data structure.
|
|
% XXX Should maybe changed at a later date.
|
|
%
|
|
%---------------------------------------------------------------------------%
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- module prof_info.
|
|
:- interface.
|
|
|
|
:- import_module list.
|
|
:- import_module map.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
% prof: Data structure which contains ALL the relevant info for use
|
|
% in generating the output.
|
|
:- type prof.
|
|
|
|
% Maps label names to label addresses.
|
|
:- type addrdecl == map(string, int).
|
|
|
|
% Maps label addresses to prof nodes.
|
|
:- type prof_node_map == map(int, prof_node).
|
|
|
|
% Maps predicate names to the cycle the predicate is in.
|
|
:- type cycle_map == map(string, int).
|
|
|
|
% prof_node: Contains all the info used for output, for a single pred.
|
|
:- type prof_node.
|
|
|
|
:- type pred_info.
|
|
|
|
:- type prof_node_type
|
|
---> predicate
|
|
; cycle.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
% Initialise prof predicates.
|
|
%
|
|
:- func prof_node_init(string) = prof_node.
|
|
|
|
:- func prof_node_init_cycle(string, int, int, float, list(pred_info), int,
|
|
int) = prof_node.
|
|
|
|
% Get prof_node from via predicate name.
|
|
%
|
|
:- pred get_prof_node(string::in, addrdecl::in, prof_node_map::in,
|
|
prof_node::out) is det.
|
|
|
|
:- pred update_prof_node(string::in, prof_node::in, addrdecl::in,
|
|
prof_node_map::in, prof_node_map::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% `prof' access predicates.
|
|
%
|
|
|
|
:- pred prof_get_entire(prof::in, float::out, string::out, int::out,
|
|
addrdecl::out, prof_node_map::out, cycle_map::out) is det.
|
|
|
|
:- pred prof_get_addrdeclmap(prof::in, addrdecl::out) is det.
|
|
:- pred prof_get_profnodemap(prof::in, prof_node_map::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% `prof' update predicates.
|
|
%
|
|
|
|
:- pred prof_set_entire(float::in, string::in, int::in, addrdecl::in,
|
|
prof_node_map::in, cycle_map::in, prof::out) is det.
|
|
|
|
:- pred prof_set_profnodemap(prof_node_map::in, prof::in, prof::out) is det.
|
|
:- pred prof_set_cyclemap(cycle_map::in, prof::in, prof::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Special prof_node predicates.
|
|
%
|
|
|
|
:- pred prof_node_type(prof_node::in, prof_node_type::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Access Predicate for prof_node.
|
|
%
|
|
|
|
:- pred prof_node_get_entire_pred(prof_node::in, string::out, int::out,
|
|
int::out, float::out, list(pred_info)::out, list(pred_info)::out,
|
|
int::out, int::out, list(string)::out) is det.
|
|
|
|
:- pred prof_node_get_entire_cycle(prof_node::in, string::out, int::out,
|
|
int::out, float::out, list(pred_info)::out, int::out, int::out) is det.
|
|
|
|
:- pred prof_node_get_pred_name(prof_node::in, string::out) is det.
|
|
:- pred prof_node_get_cycle_number(prof_node::in, int::out) is det.
|
|
:- pred prof_node_get_initial_counts(prof_node::in, int::out) is det.
|
|
:- pred prof_node_get_propagated_counts(prof_node::in, float::out) is det.
|
|
:- pred prof_node_get_parent_list(prof_node::in, list(pred_info)::out) is det.
|
|
:- pred prof_node_get_child_list(prof_node::in, list(pred_info)::out) is det.
|
|
:- pred prof_node_get_total_calls(prof_node::in, int::out) is det.
|
|
:- pred prof_node_get_self_calls(prof_node::in, int::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Update prof_node predicates.
|
|
%
|
|
|
|
:- pred prof_node_set_cycle_num(int::in, prof_node::in, prof_node::out) is det.
|
|
|
|
:- pred prof_node_set_initial_counts(int::in, prof_node::in, prof_node::out)
|
|
is det.
|
|
|
|
:- pred prof_node_set_propagated_counts(float::in, prof_node::in,
|
|
prof_node::out) is det.
|
|
|
|
:- pred prof_node_concat_to_parent(string::in, int::in,
|
|
prof_node::in, prof_node::out) is det.
|
|
|
|
:- pred prof_node_concat_to_child(string::in, int::in,
|
|
prof_node::in, prof_node::out) is det.
|
|
|
|
:- pred prof_node_set_total_calls(int::in,
|
|
prof_node::in, prof_node::out) is det.
|
|
|
|
:- pred prof_node_set_self_calls(int::in,
|
|
prof_node::in, prof_node::out) is det.
|
|
|
|
:- pred prof_node_concat_to_name_list(string::in,
|
|
prof_node::in, prof_node::out) is det.
|
|
|
|
:- pred prof_node_concat_to_member(string::in, int::in,
|
|
prof_node::in, prof_node::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Init predicates for pred_info.
|
|
%
|
|
|
|
:- pred pred_info_init(string::in, int::in, pred_info::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Access predicates for pred_info.
|
|
%
|
|
|
|
:- pred pred_info_get_entire(pred_info::in, string::out, int::out) is det.
|
|
:- pred pred_info_get_pred_name(pred_info::in, string::out) is det.
|
|
:- pred pred_info_get_counts(pred_info::in, int::out) is det.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%---------------------------------------------------------------------------%
|
|
|
|
:- implementation.
|
|
|
|
:- import_module require.
|
|
|
|
:- type prof
|
|
---> prof(
|
|
% Scaling factor.
|
|
scaling_factor :: float,
|
|
|
|
% Units (Each profiling count is equivalent to Scale Units).
|
|
units :: string,
|
|
|
|
% Total counts of the profile run.
|
|
total_count :: int,
|
|
|
|
% Map between label name and label addr used to find key
|
|
% to look up prof_node_map.
|
|
addr_decl_map :: addrdecl,
|
|
|
|
% Map between label addresses and all the relevant data
|
|
% about that predicate.
|
|
prof_node_map :: prof_node_map,
|
|
|
|
% Map between predicate name and its cycle number.
|
|
cycle_map :: cycle_map
|
|
).
|
|
|
|
:- type prof_node
|
|
---> pred_node(
|
|
% A node which consists of just one predicate.
|
|
|
|
pred_name :: string,
|
|
pred_cycle_number :: int,
|
|
pred_self_counts :: int,
|
|
pred_propagated_counts :: float,
|
|
|
|
% Parent pred and the number of times it calls this predicate.
|
|
% XXX
|
|
pred_parent_list :: list(pred_info),
|
|
|
|
% Child pred and the number of times they are called
|
|
% from this predicate.
|
|
pred_child_list :: list(pred_info),
|
|
|
|
% Total count of times this predicate called.
|
|
pred_total_calls :: int,
|
|
|
|
% Number of self recursive calls of this routine.
|
|
pred_self_calls :: int,
|
|
|
|
% Alternative names for this predicate, e.g. labels with
|
|
% different names but the same address.
|
|
prd_name_list :: list(string)
|
|
)
|
|
; cycle_node(
|
|
% A node which is built up with more than one predicate
|
|
% and is a cycle.
|
|
|
|
cycle_name :: string,
|
|
cycle_cycle_number :: int,
|
|
cycle_self_counts :: int,
|
|
cycle_propagated_counts :: float,
|
|
|
|
% Cycle members plus total calls to that predicate.
|
|
% XXX
|
|
cycle_members :: list(pred_info),
|
|
|
|
% Total count of times this predicate called.
|
|
% XXX
|
|
cycle_total_calls :: int,
|
|
|
|
% Number of calls to fellow cycle members.
|
|
cycle_self_calls :: int
|
|
).
|
|
|
|
:- type pred_info
|
|
---> pred_info(
|
|
pred_info_name :: string, % predicate (label)
|
|
pred_info_count :: int % count (to or from)
|
|
).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Initialise predicates.
|
|
%
|
|
|
|
prof_node_init(PredName) =
|
|
pred_node(PredName, 0, 0, 0.0, [], [], 0, 0, []).
|
|
|
|
prof_node_init_cycle(A, B, C, D, E, F, G) =
|
|
cycle_node(A, B, C, D, E, F, G).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
|
|
get_prof_node(Pred, AddrMap, ProfNodeMap, ProfNode) :-
|
|
map.lookup(AddrMap, Pred, Key),
|
|
map.lookup(ProfNodeMap, Key, ProfNode).
|
|
|
|
update_prof_node(Pred, ProfNode, AddrMap, !ProfNodeMap) :-
|
|
map.lookup(AddrMap, Pred, Key),
|
|
map.det_update(Key, ProfNode, !ProfNodeMap).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Access prof predicates.
|
|
%
|
|
|
|
prof_get_entire(prof(A, B, C, D, E, F), A, B, C, D, E, F).
|
|
|
|
prof_get_addrdeclmap(Prof, X) :-
|
|
X = Prof ^ addr_decl_map.
|
|
prof_get_profnodemap(Prof, X) :-
|
|
X = Prof ^ prof_node_map.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Update prof predicates.
|
|
%
|
|
|
|
prof_set_entire(A, B, C, D, E, F, prof(A, B, C, D, E, F)).
|
|
|
|
prof_set_profnodemap(X, !Prof) :-
|
|
!Prof ^ prof_node_map := X.
|
|
prof_set_cyclemap(X, !Prof) :-
|
|
!Prof ^ cycle_map := X.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Special prof_node predicates.
|
|
%
|
|
|
|
prof_node_type(pred_node(_, _, _, _, _, _, _, _, _), predicate).
|
|
prof_node_type(cycle_node(_, _, _, _, _, _, _), cycle).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Access prof_node predicates.
|
|
%
|
|
|
|
prof_node_get_entire_pred(pred_node(A,B,C,D,E,F,G,H,I),A,B,C,D,E,F,G,H,I).
|
|
prof_node_get_entire_pred(cycle_node(_,_,_,_,_,_,_),_,_,_,_,_,_,_,_,_) :-
|
|
error("prof_node_get_entire_pred: not a pred\n").
|
|
|
|
prof_node_get_entire_cycle(cycle_node(A,B,C,D,E,F,G),A,B,C,D,E,F,G).
|
|
prof_node_get_entire_cycle(pred_node(_,_,_,_,_,_,_,_,_),_,_,_,_,_,_,_) :-
|
|
error("prof_node_get_entire_cycle: not a cycle\n").
|
|
|
|
prof_node_get_pred_name(pred_node(Name, _, _, _, _, _, _, _, _), Name).
|
|
prof_node_get_pred_name(cycle_node(Name, _, _, _, _, _, _), Name).
|
|
|
|
prof_node_get_cycle_number(pred_node(_, Cycle, _, _, _, _, _, _, _), Cycle).
|
|
prof_node_get_cycle_number(cycle_node(_, Cycle, _, _, _, _, _), Cycle).
|
|
|
|
prof_node_get_initial_counts(pred_node(_, _, Count, _, _, _, _, _, _), Count).
|
|
prof_node_get_initial_counts(cycle_node(_, _, Count, _, _, _, _), Count).
|
|
|
|
prof_node_get_propagated_counts(pred_node(_, _, _, Count,_,_,_,_,_), Count).
|
|
prof_node_get_propagated_counts(cycle_node(_, _, _, Count, _, _, _), Count).
|
|
|
|
prof_node_get_parent_list(pred_node(_, _, _, _, PList, _, _, _, _), PList).
|
|
prof_node_get_parent_list(cycle_node(_, _, _, _, _, _, _), _) :-
|
|
error("prof_node_get_parent_list: cycle_node has no parent list\n").
|
|
|
|
prof_node_get_child_list(pred_node(_, _, _, _, _, Clist, _, _, _), Clist).
|
|
prof_node_get_child_list(cycle_node(_, _, _, _, _, _, _), _) :-
|
|
error("prof_node_get_child_list: cycle_node has no child list\n").
|
|
|
|
prof_node_get_total_calls(pred_node(_, _, _, _, _, _, Calls, _, _), Calls).
|
|
prof_node_get_total_calls(cycle_node(_, _, _, _, _, Calls, _), Calls).
|
|
|
|
prof_node_get_self_calls(pred_node(_, _, _, _, _, _, _, Calls, _), Calls).
|
|
prof_node_get_self_calls(cycle_node(_, _, _, _, _, _, Calls), Calls).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Update prof_node predicates.
|
|
%
|
|
|
|
prof_node_set_cycle_num(Cycle, pred_node(A, _, C, D, E, F, G, H, I),
|
|
pred_node(A, Cycle, C, D, E, F, G, H, I)).
|
|
prof_node_set_cycle_num(Cycle, cycle_node(A, _, C, D, E, F, G),
|
|
cycle_node(A, Cycle, C, D, E, F, G)).
|
|
|
|
prof_node_set_initial_counts(Count, pred_node(A, B, _, D, E, F, G, H, I),
|
|
pred_node(A, B, Count, D, E, F, G, H, I)).
|
|
prof_node_set_initial_counts(Count, cycle_node(A, B, _, D, E, F, G),
|
|
cycle_node(A, B, Count, D, E, F, G)).
|
|
|
|
prof_node_set_propagated_counts(Count, pred_node(A, B, C, _, E, F, G, H, I),
|
|
pred_node(A, B, C, Count, E, F, G, H, I)).
|
|
prof_node_set_propagated_counts(Count, cycle_node(A, B, C, _, E, F, G),
|
|
cycle_node(A, B, C, Count, E, F, G)).
|
|
|
|
prof_node_concat_to_parent(Name,Count, pred_node(A, B, C, D, PList, F, G, H, I),
|
|
pred_node(A, B, C, D, [pred_info(Name,Count) | PList], F, G, H, I)).
|
|
prof_node_concat_to_parent(_, _, cycle_node(_, _, _, _, _, _, _), _) :-
|
|
error("prof_node_concat_to_parent: cycle_node has no parents\n").
|
|
|
|
prof_node_concat_to_child(Name, Count, pred_node(A, B, C, D, E, CList, G, H, I),
|
|
pred_node(A, B, C, D, E, [pred_info(Name,Count) | CList], G, H, I)).
|
|
prof_node_concat_to_child(_, _, cycle_node(_, _, _, _, _, _, _), _) :-
|
|
error("prof_node_concat_to_child: cycle_node has no child\n").
|
|
|
|
prof_node_set_total_calls(Calls, pred_node(A, B, C, D, E, F, _, H, I),
|
|
pred_node(A, B, C, D, E, F, Calls, H, I)).
|
|
prof_node_set_total_calls(Calls, cycle_node(A, B, C, D, E, _, G),
|
|
cycle_node(A, B, C, D, E, Calls, G)).
|
|
|
|
prof_node_set_self_calls(Calls, pred_node(A, B, C, D, E, F, G, _, I),
|
|
pred_node(A, B, C, D, E, F, G, Calls, I)).
|
|
prof_node_set_self_calls(Calls, cycle_node(A, B, C, D, E, F, _),
|
|
cycle_node(A, B, C, D, E, F, Calls)).
|
|
|
|
prof_node_concat_to_name_list(Name, pred_node(A, B, C, D, E, F, G, H, NL),
|
|
pred_node(A, B, C, D, E, F, G, H, [Name | NL])).
|
|
prof_node_concat_to_name_list(_, cycle_node(_, _, _, _, _, _, _), _) :-
|
|
error("prof_node_concat_to_name_list: cycle_node has no namelist\n").
|
|
|
|
prof_node_concat_to_member(Name, Count, cycle_node(A, B, C, D, CList, F, G),
|
|
cycle_node(A, B, C, D, [pred_info(Name,Count) | CList], F, G)).
|
|
prof_node_concat_to_member(_, _, pred_node(_, _, _, _, _, _, _, _, _), _) :-
|
|
error("prof_node_concat_to_member: pred_node has no members\n").
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Init predicates for pred_info.
|
|
|
|
pred_info_init(Name, Count, pred_info(Name, Count)).
|
|
|
|
%---------------------------------------------------------------------------%
|
|
%
|
|
% Access predicates for pred_info.
|
|
%
|
|
|
|
pred_info_get_entire(pred_info(A, B), A, B).
|
|
|
|
pred_info_get_pred_name(Pred, X) :-
|
|
X = Pred ^ pred_info_name.
|
|
pred_info_get_counts(Pred, X) :-
|
|
X = Pred ^ pred_info_count.
|
|
|
|
%---------------------------------------------------------------------------%
|
|
:- end_module prof_info.
|
|
%---------------------------------------------------------------------------%
|