diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
This repository has been archived on 2023-08-20. You can view files and clone it, but cannot push or open issues or pull requests.
d76c2a0039
yap-6.3/pl/statistics.yap
Vítor Santos Costa e9cc545f68 big cleanup: cpmpile under style checker. 
fix broken module stuff.
2014-10-07 01:35:41 +01:00

359 lines
12 KiB
Prolog
Raw Blame History

/*************************************************************************
* *
* YAP Prolog *
* *
* Yap Prolog was developed at NCCUP - Universidade do Porto *
* *
* Copyright L.Damas, V.S.Costa and Universidade do Porto 1985-1997 *
* *
**************************************************************************
* *
* File: statistics.yap *
* Last rev: 8/2/88 *
* mods: *
* comments: statistics on Prolog status *
* *
*************************************************************************/
:- system_module( '$_statistics', [key_statistics/3,
statistics/0,
statistics/2,
time/1], []).
:- use_system_module( '$_errors', ['$do_error'/2]).
%%% User interface for statistics
/** @pred statistics/0
Send to the current user error stream general information on space used and time
spent by the system.
~~~~~
?- statistics.
memory (total) 4784124 bytes
program space 3055616 bytes: 1392224 in use, 1663392 free
2228132 max
stack space 1531904 bytes: 464 in use, 1531440 free
global stack: 96 in use, 616684 max
local stack: 368 in use, 546208 max
trail stack 196604 bytes: 8 in use, 196596 free
0.010 sec. for 5 code, 2 stack, and 1 trail space overflows
0.130 sec. for 3 garbage collections which collected 421000 bytes
0.000 sec. for 0 atom garbage collections which collected 0 bytes
0.880 sec. runtime
1.020 sec. cputime
25.055 sec. elapsed time
~~~~~
The example shows how much memory the system spends. Memory is divided
into Program Space, Stack Space and Trail. In the example we have 3MB
allocated for program spaces, with less than half being actually
used. YAP also shows the maximum amount of heap space having been used
which was over 2MB.
The stack space is divided into two stacks which grow against each
other. We are in the top level so very little stack is being used. On
the other hand, the system did use a lot of global and local stack
during the previous execution (we refer the reader to a WAM tutorial in
order to understand what are the global and local stacks).
YAP also shows information on how many memory overflows and garbage
collections the system executed, and statistics on total execution
time. Cputime includes all running time, runtime excludes garbage
collection and stack overflow time.
*/
statistics :-
'$runtime'(Runtime,_),
'$cputime'(CPUtime,_),
'$systime'(SYStime,_),
'$walltime'(Walltime,_),
'$statistics_heap_info'(HpSpa, HpInUse),
'$statistics_heap_max'(HpMax),
'$statistics_trail_info'(TrlSpa, TrlInUse),
'$statistics_trail_max'(TrlMax),
'$statistics_stacks_info'(StkSpa, GlobInU, LocInU),
'$statistics_global_max'(GlobMax),
'$statistics_local_max'(LocMax),
'$inform_heap_overflows'(NOfHO,TotHOTime),
'$inform_stack_overflows'(NOfSO,TotSOTime),
'$inform_trail_overflows'(NOfTO,TotTOTime),
'$inform_gc'(NOfGC,TotGCTime,TotGCSize),
'$inform_agc'(NOfAGC,TotAGCTime,TotAGCSize),
'$statistics'(Runtime,CPUtime,SYStime,Walltime,HpSpa,HpInUse,HpMax,TrlSpa, TrlInUse,TrlMax,StkSpa, GlobInU, LocInU,GlobMax,LocMax,NOfHO,TotHOTime,NOfSO,TotSOTime,NOfTO,TotTOTime,NOfGC,TotGCTime,TotGCSize,NOfAGC,TotAGCTime,TotAGCSize).
'$statistics'(Runtime,CPUtime,SYStime,Walltime,HpSpa,HpInUse,HpMax,TrlSpa, TrlInUse,_TrlMax,StkSpa, GlobInU, LocInU,GlobMax,LocMax,NOfHO,TotHOTime,NOfSO,TotSOTime,NOfTO,TotTOTime,NOfGC,TotGCTime,TotGCSize,NOfAGC,TotAGCTime,TotAGCSize) :-
TotalMemory is HpSpa+StkSpa+TrlSpa,
format(user_error,'memory (total)~t~d bytes~35+~n', [TotalMemory]),
format(user_error,' program space~t~d bytes~35+', [HpSpa]),
format(user_error,':~t ~d in use~19+', [HpInUse]),
HpFree is HpSpa-HpInUse,
format(user_error,',~t ~d free~19+~n', [HpFree]),
format(user_error,'~t ~d max~73+~n', [HpMax]),
format(user_error,' stack space~t~d bytes~35+', [StkSpa]),
StackInUse is GlobInU+LocInU,
format(user_error,':~t ~d in use~19+', [StackInUse]),
StackFree is StkSpa-StackInUse,
format(user_error,',~t ~d free~19+~n', [StackFree]),
format(user_error,' global stack:~t~35+', []),
format(user_error,' ~t ~d in use~19+', [GlobInU]),
format(user_error,',~t ~d max~19+~n', [GlobMax]),
format(user_error,' local stack:~t~35+', []),
format(user_error,' ~t ~d in use~19+', [LocInU]),
format(user_error,',~t ~d max~19+~n', [LocMax]),
format(user_error,' trail stack~t~d bytes~35+', [TrlSpa]),
format(user_error,':~t ~d in use~19+', [TrlInUse]),
TrlFree is TrlSpa-TrlInUse,
format(user_error,',~t ~d free~19+~n', [TrlFree]),
OvfTime is (TotHOTime+TotSOTime+TotTOTime)/1000,
format(user_error,'~n~t~3f~12+ sec. for ~w code, ~w stack, and ~w trail space overflows~n',
[OvfTime,NOfHO,NOfSO,NOfTO]),
TotGCTimeF is float(TotGCTime)/1000,
format(user_error,'~t~3f~12+ sec. for ~w garbage collections which collected ~d bytes~n',
[TotGCTimeF,NOfGC,TotGCSize]),
TotAGCTimeF is float(TotAGCTime)/1000,
format(user_error,'~t~3f~12+ sec. for ~w atom garbage collections which collected ~d bytes~n',
[TotAGCTimeF,NOfAGC,TotAGCSize]),
RTime is float(Runtime)/1000,
format(user_error,'~t~3f~12+ sec. runtime~n', [RTime]),
CPUTime is float(CPUtime)/1000,
format(user_error,'~t~3f~12+ sec. cputime~n', [CPUTime]),
SYSTime is float(SYStime)/1000,
format(user_error,'~t~3f~12+ sec. systime~n', [SYSTime]),
WallTime is float(Walltime)/1000,
format(user_error,'~t~3f~12+ sec. elapsed time~n~n', [WallTime]),
fail.
'$statistics'(_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_,_).
/** @pred statistics(? _Param_,- _Info_)
Gives statistical information on the system parameter given by first
argument:
+ atoms
`[ _NumberOfAtoms_, _SpaceUsedBy Atoms_]`
This gives the total number of atoms `NumberOfAtoms` and how much
space they require in bytes, _SpaceUsedBy Atoms_.
+ cputime
`[ _Time since Boot_, _Time From Last Call to Cputime_]`
This gives the total cputime in milliseconds spent executing Prolog code,
garbage collection and stack shifts time included.
+ dynamic_code
`[ _Clause Size_, _Index Size_, _Tree Index Size_, _Choice Point Instructions Size_, _Expansion Nodes Size_, _Index Switch Size_]`
Size of static code in YAP in bytes: _Clause Size_, the number of
bytes allocated for clauses, plus
_Index Size_, the number of bytes spent in the indexing code. The
indexing code is divided into main tree, _Tree Index Size_,
tables that implement choice-point manipulation, _Choice xsPoint Instructions Size_, tables that cache clauses for future expansion of the index
tree, _Expansion Nodes Size_, and
tables such as hash tables that select according to value, _Index Switch Size_.
+ garbage_collection
`[ _Number of GCs_, _Total Global Recovered_, _Total Time Spent_]`
Number of garbage collections, amount of space recovered in kbytes, and
total time spent doing garbage collection in milliseconds. More detailed
information is available using `yap_flag(gc_trace,verbose)`.
+ global_stack
`[ _Global Stack Used_, _Execution Stack Free_]`
Space in kbytes currently used in the global stack, and space available for
expansion by the local and global stacks.
+ local_stack
`[ _Local Stack Used_, _Execution Stack Free_]`
Space in kbytes currently used in the local stack, and space available for
expansion by the local and global stacks.
+ heap
`[ _Heap Used_, _Heap Free_]`
Total space in kbytes not recoverable
in backtracking. It includes the program code, internal data base, and,
atom symbol table.
+ program
`[ _Program Space Used_, _Program Space Free_]`
Equivalent to heap.
+ runtime
`[ _Time since Boot_, _Time From Last Call to Runtime_]`
This gives the total cputime in milliseconds spent executing Prolog
code, not including garbage collections and stack shifts. Note that
until YAP4.1.2 the runtime statistics would return time spent on
garbage collection and stack shifting.
+ stack_shifts
`[ _Number of Heap Shifts_, _Number of Stack Shifts_, _Number of Trail Shifts_]`
Number of times YAP had to
expand the heap, the stacks, or the trail. More detailed information is
available using `yap_flag(gc_trace,verbose)`.
+ static_code
`[ _Clause Size_, _Index Size_, _Tree Index Size_, _Expansion Nodes Size_, _Index Switch Size_]`
Size of static code in YAP in bytes: _Clause Size_, the number of
bytes allocated for clauses, plus
_Index Size_, the number of bytes spent in the indexing code. The
indexing code is divided into a main tree, _Tree Index Size_, table that cache clauses for future expansion of the index
tree, _Expansion Nodes Size_, and and
tables such as hash tables that select according to value, _Index Switch Size_.
+ trail
`[ _Trail Used_, _Trail Free_]`
Space in kbytes currently being used and still available for the trail.
+ walltime
`[ _Time since Boot_, _Time From Last Call to Walltime_]`
This gives the clock time in milliseconds since starting Prolog.
*/
statistics(runtime,[T,L]) :-
'$runtime'(T,L).
statistics(cputime,[T,L]) :-
'$cputime'(T,L).
statistics(walltime,[T,L]) :-
'$walltime'(T,L).
statistics(threads,NT) :-
'$nof_threads'(NT).
statistics(threads_created,TC) :-
'$nof_threads_created'(TC).
statistics(thread_cputime,TR) :-
'$thread_runtime'(TR).
%statistics(core,[_]).
%statistics(memory,[_]).
statistics(heap,[Hp,HpF]) :-
'$statistics_heap_info'(HpM, Hp),
HpF is HpM-Hp.
statistics(program,Info) :-
statistics(heap,Info).
statistics(global_stack,[GlobInU,GlobFree]) :-
'$statistics_stacks_info'(StkSpa, GlobInU, LocInU),
GlobFree is StkSpa-GlobInU-LocInU.
statistics(local_stack,[LocInU,LocFree]) :-
'$statistics_stacks_info'(StkSpa, GlobInU, LocInU),
LocFree is StkSpa-GlobInU-LocInU.
statistics(trail,[TrlInUse,TrlFree]) :-
'$statistics_trail_info'(TrlSpa, TrlInUse),
TrlFree is TrlSpa-TrlInUse.
statistics(garbage_collection,[NOfGC,TotGCSize,TotGCTime]) :-
'$inform_gc'(NOfGC,TotGCTime,TotGCSize).
statistics(stack_shifts,[NOfHO,NOfSO,NOfTO]) :-
'$inform_heap_overflows'(NOfHO,_),
'$inform_stack_overflows'(NOfSO,_),
'$inform_trail_overflows'(NOfTO,_).
statistics(atoms,[NOf,SizeOf]) :-
'$statistics_atom_info'(NOf,SizeOf).
statistics(static_code,[ClauseSize, IndexSize, TreeIndexSize, ExtIndexSize, SWIndexSize]) :-
'$statistics_db_size'(ClauseSize, TreeIndexSize, ExtIndexSize, SWIndexSize),
IndexSize is TreeIndexSize+ ExtIndexSize+ SWIndexSize.
statistics(dynamic_code,[ClauseSize,IndexSize, TreeIndexSize, CPIndexSize, ExtIndexSize, SWIndexSize]) :-
'$statistics_lu_db_size'(ClauseSize, TreeIndexSize, CPIndexSize, ExtIndexSize, SWIndexSize),
IndexSize is TreeIndexSize+CPIndexSize+ ExtIndexSize+ SWIndexSize.
/** @pred key_statistics(+ _K_,- _Entries_,- _TotalSize_)
Returns several statistics for a key _K_. Currently, it says how
many entries we have for that key, _Entries_, what is the
total size spent on this key.
*/
key_statistics(Key, NOfEntries, TotalSize) :-
key_statistics(Key, NOfEntries, ClSize, IndxSize),
TotalSize is ClSize+IndxSize.
%% time(:Goal)
%
% Time the execution of Goal. Possible choice-points of Goal are removed.
% Based on the SWI-Prolog definition minus reporting the number of inferences,
% which YAP does not currently supports
/** @pred time(: _Goal_)
Prints the CPU time and the wall time for the execution of _Goal_.
Possible choice-points of _Goal_ are removed. Based on the SWI-Prolog
definition (minus reporting the number of inferences, which YAP currently
does not support).
*/
:- meta_predicate time(0).
time(Goal) :-
var(Goal),
'$do_error'(instantiation_error,time(Goal)).
time(_:Goal) :-
var(Goal),
'$do_error'(instantiation_error,time(Goal)).
time(Goal) :- \+ callable(Goal), !,
'$do_error'(type_error(callable,Goal),time(Goal)).
time(Goal) :-
statistics(walltime, _),
statistics(cputime, _),
( catch(Goal, E, true)
-> Result = yes
; Result = no
),
statistics(cputime, [_, Time]),
statistics(walltime, [_, Wall]),
( Time =:= 0
-> CPU = 'Inf'
; CPU is truncate(Time/Wall*100)
),
TimeSecs is Time/1000,
WallSecs is Wall/1000,
format(user_error,'% ~3f CPU in ~3f seconds (~|~t~w~3+% CPU)~n', [TimeSecs, WallSecs, CPU]),
( nonvar(E)
-> throw(E)
; Result == yes
).
Reference in New Issue View Git Blame Copy Permalink