Monitoring Programs

• one convenient model for running MPs is to give the SP and its command-line arguments on the command line after the MP
  
• for example, if the SP is run by itself as

rsg -l 1000 <rsg.dat

then it would be monitored by an MP allocview as

allocview rsg -l 1000 <rsg.dat

• the structure of an MP for this model is:

link evinit                # support procedures

$include "evdefs.icn"      # event definitions

procedure main(args)

   EvInit(args) | ...      # load and launch the SP

   while EvGet() do {      # request event in SP
         ...               # process event
      }

                           # final processing (if any)

end

• the library module evinit includes procedures that support monitoring activities
• the include file evdefs.icn (on LPATH) provides symbolic definitions for event codes
  
• args provides the command line arguments, including the program to load and its arguments
  
• EvInit(args) calls load() with the SP and its command-line arguments, and initializes monitoring; it may fail
  
• the call of EvGet() requests an event and turns control over to the SP
  
• when an event occurs, the procedure EvGet() returns and the event code and value are set in &eventcode and &eventvalue in the MP
  
• the MP takes actions depending on the values of these keywords
  
• note that in the case of an event such as set membership test, &eventvalue contains (a pointer to) the set in SP
  
• an argument to EvGet() can be used to specify the kinds of events that are wanted
  
• such arguments are called masks
  
• there are symbolic names for frequently used masks; for example, StructMask is the name of the mask for structure access events
  
• thus

EvGet(StructMask)

limits the kinds of events reported to those associated with structure access

• here's a simple MP that tabulates procedure activity:

link evinit

$include "evdefs.icn"

procedure main(args)

   EvInit(args) | stop("*** cannot load icode file ***")

   proact := table(0)

   # Tabulate procedure events.

   while EvGet(ProcMask) do
      proact[&eventcode] +:= 1

  # List the results.

   write("procedure calls:       ",right(proact[E_Pcall], 6)) 
   write("procedure returns:     ", right(proact[E_Pret], 6))
   write("procedure suspensions: ", right(proact[E_Psusp], 6))
   write("procedure failures:    ", right(proact[E_Pfail], 6))
   write("procedure resumptions: ", right(proact[E_Presum], 6))
   write("procedure removals:    ", right(proact[E_Prem], 6))

end

• The procedure events, included in ProcMask, are:

  E_Pcall    procedure call                
  E_Pfail    procedure failure              
  E_Prem     suspended procedure removal    
  E_Presum   procedure resumption           
  E_Pret     procedure return 
  E_Psusp    procedure suspension

• the output for chess is

procedure calls:        6333
procedure returns:       947
procedure suspensions: 15628
procedure failures:     5344
procedure resumptions: 15586
procedure removals:       42

• note the amount of generation by procedures
  
• the removals are for suspended procedures when leaving bounded expressions
  
• this MP only produces a tabulation; another might show an animated visualization of procedure activity