Peter writes:
> I want to log the cpu-time spend searching a data base.
> I looked at the PROCTIME intrinsic, but this will only tell me
> how much CPU time is spend in the current process. In this case
> the user-interface is launching sub processes to do the searches.
Here's how I obtain the CPU time for a job/session ... note that it
uses one AIF routine and one internal routine (get_proc_cpu_time), and that
it is not complete as shown (I omitted the get_pin_tree_cpu routine,
but provided a high-level description of how to write one...
Sorry, but that's the best compromise I can do between help and income.
Nevertheless, it should suffice to allow implementation of what you
desire.
NOTE: get_proc_cpu_time is an MPE internal routine .. and, as such, is
subject to change. There may be an equivalent AIF routine that you could
call instead. get_proc_cpu_time has been in MPE since at least 1.0 (I
wrote it.)
<<-------------------------------------------------------------------
Notes for non-SPLash! programmers:
double = 32 bit signed integer
integer = 16 bit signed integer
logical = 16 bit unsigned integer
long = 64 bit real (used here as a method of easily manipulating
64-bit addresses as non-pointers)
---------------------------------------------------------------------
get_pin_tree_cpu, referred to in get_job_cpu below, is a routine of mine
that adds the CPU time for every process in a process tree (including the
"top" process (the one you pass into it). This routine could be
implemented by calling PROCINFO (item # 7) on the "top" pin (the
CI in the case of get_job_cpu), and then using the get_pin_cpu
routine for each process returned by PROCINFO. get_pin_cpu isn't trivial,
so I included it below.
--------------------------------------------------------------------->>
double procedure get_job_cpu (status, priv_controls, jsnum, alive_too);
value jsnum, alive_too;
logical jsnum, alive_too;
double status;
double array priv_controls;
option privileged, nocc;
<<------------------------------------------------------------
Purpose:
Returns CPU time that a job has used.
NOTE: the aifjsget routine does *NOT* include the CPU time
used by processes that are still alive!
If the alive_too parameter is true, then the value will
include the CPU time of all the living processes, as well
as processes that have already terminated.
Method: get CPU for dead processes (via aifjsget), and then
walk the tree of living processes (starting at the CI) and
add up their CPU time, add result to the aifjsget value.
Limitations:
get_pcl is not used, so a process could terminate between the
aifjsget and the process-tree walk, and therefore have its
CPU time go uncounted by this routine. Workaround would be
to call aifjsget a second time, and if different, redo the
process walk (until the aifjsget returns the same value twice
in a row).
Note: get_pcl cannot be used due to a design flaw in the
implementation of aifjsget.
------------------------------------------------------------>>
begin
fullvirtual pointer
ptr; ! 64 bits
long
ptr_z = ptr; ! 64 bits
long array
items (0 : 2); ! 3 * 64 bits
double array
itemerrs (0 : 2),
itemnums (0 : 2);
double
billed_cpu := 0,
ci_pin := 0,
numpins := 0,
jsnum_rec := 0,
tree_cpu := 0;
logical
jsnum_rec_1 = jsnum_rec, ! upper 16 bits of jsnum_rec
jsnum_rec_2 = jsnum_rec + 1; ! lower 16 bits of jsnum_rec
intrinsic (aifintr.pub.sys)
aifjsget;
get_job_cpu := 0;
status := 0;
itemerrs (0) :=0;
! build items...
itemnums (0) := 1028; ! get CPU count (for dead procs)
itemnums (1) := 1018; ! get CI pin (for alive_too)
itemnums (2) := 0; ! stopper
@ptr := @billed_cpu;
items (0) := ptr_z; ! set first 64 bits to the
! 64-bit virt addr of billed_cpu
@ptr := @ci_pin; ! set second 64 bits of items to
items (1) := ptr_z; ! the 64-bit virt addr of ci_pin
! call aifjsget... REQUIRES THAT YOU ARE IN PRIV MODE!
jsnum_rec_1 := jsnum;
jsnum_rec_2 := 0;
aifjsget (status, itemnums, items, itemerrs, jsnum_rec, 0, aif_id);
if status <> 0 then
begin ! failed...
if itemerrs (0) <> 0 then
status := itemerrs (0)
else if itemerrs (1) <> 0 then
status := itemerrs (1);
go end_proc;
end;
if alive_too then
begin
if ci_pin = 0 then ! did we fail to determine it?
begin
status := -2;
go end_proc;
end;
if get_pin_tree_cpu (priv_controls, ci_pin, tree_cpu, numpins)
= false then
;
end;
get_job_cpu := billed_cpu + tree_cpu;
end_proc:
end <<get_job_cpu proc>>;
<<*************************************************************>>
double procedure get_pin_cpu (pin); ! NOTE: assumes pin is in valid range!
value pin;
double pin;
option privileged, nocc;
begin
long
cputime_z; ! 64 bits
double
cputime_1 = cputime_z, ! high 32 bits
cputime_2 = cputime_z + 2; ! low 32 bits
long Procedure get_proc_cpu_time (pin); ! MPE internal
value pin;
double pin;
option external, native, nocc;
! Internal MPE XL cpu is in micro seconds.
cputime_z := get_proc_cpu_time (pin);
! Note: if cputime_z > 546 hours, then in milliseconds it
! will overflow 2**31-1 ! ...so we check for this case (obscurely)
! and return a big number of milliseconds if the overflow happens...
! the best we can do for a very unlikely event, without adding extra
! error returning parameters.
!
! SPLash! lacks 64-bit integer arithmetic, so we call a helper
! routine (written in Pascal/iX) to divide a 64-bit integer by a
! 32 bit integer, and thereby obtain CPU milliseconds...
if cputime_1 >= $1f3 d then ! SS 921117
get_pin_cpu := 2147000000 d ! SS 921117
else
get_pin_cpu := div64_32_32 (cputime_z, 1000d);
end <<get_pin_cpu proc>>;
<<*****************************************************************>>
--
Stan Sieler [log in to unmask]
http://www.allegro.com/sieler.html
|
