paradyn/h/dyninstRPC.I

   1 /*
   2  * Copyright (c) 1996 Barton P. Miller
   3  *
   4  * We provide the Paradyn Parallel Performance Tools (below
   5  * described as Paradyn") on an AS IS basis, and do not warrant its
   6  * validity or performance.  We reserve the right to update, modify,
   7  * or discontinue this software at any time.  We shall have no
   8  * obligation to supply such updates or modifications or any other
   9  * form of support to you.
  10  *
  11  * This license is for research uses.  For such uses, there is no
  12  * charge. We define "research use" to mean you may freely use it
  13  * inside your organization for whatever purposes you see fit. But you
  14  * may not re-distribute Paradyn or parts of Paradyn, in any form
  15  * source or binary (including derivatives), electronic or otherwise,
  16  * to any other organization or entity without our permission.
  17  *
  18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
  19  *
  20  * All warranties, including without limitation, any warranty of
  21  * merchantability or fitness for a particular purpose, are hereby
  22  * excluded.
  23  *
  24  * By your use of Paradyn, you understand and agree that we (or any
  25  * other person or entity with proprietary rights in Paradyn) are
  26  * under no obligation to provide either maintenance services,
  27  * update services, notices of latent defects, or correction of
  28  * defects for Paradyn.
  29  *
  30  * Even if advised of the possibility of such damages, under no
  31  * circumstances shall we (or any other person or entity with
  32  * proprietary rights in the software licensed hereunder) be liable
  33  * to you or any third party for direct, indirect, or consequential
  34  * damages of any character regardless of type of action, including,
  35  * without limitation, loss of profits, loss of use, loss of good
  36  * will, or computer failure or malfunction.  You agree to indemnify
  37  * us (and any other person or entity with proprietary rights in the
  38  * software licensed hereunder) for any and all liability it may
  39  * incur to third parties resulting from your use of Paradyn.
  40  */
  41
  42
  43 #define MetStyleEventCounter    0
  44 #define MetStyleSampledFunction 1
  45
  46 #include "util/h/Types.h"
  47 #include "util/h/aggregation.h"
  48 #include "paradyn/src/met/mdl.h"
  49
  50 $remote
  51 struct batch_buffer_entry {
  52    int mid;
  53    double startTimeStamp;
  54    double endTimeStamp;
  55    double value;
  56    u_int weight;
  57    bool  internal_met;
  58
  59 $ignore
  60    batch_buffer_entry &operator=(const batch_buffer_entry &src) {
  61       mid = src.mid;
  62       startTimeStamp = src.startTimeStamp;
  63       endTimeStamp = src.endTimeStamp;
  64       value = src.value;
  65       weight = src.weight;
  66       internal_met = src.internal_met;
  67       return *this;
  68    }
  69 $ignore
  70 };
  71
  72 // trace data streams
  73 $remote
  74 struct trace_batch_buffer_entry {
  75    int mid;
  76    u_int length;
  77    byteArray traceRecord;
  78
  79 $ignore
  80    trace_batch_buffer_entry &operator=(const trace_batch_buffer_entry &src) {
  81       mid = src.mid;
  82       length = src.length;
  83       traceRecord = src.traceRecord;
  84       return *this;
  85    }
  86 $ignore
  87 };
  88
  89 /* used by paradynd to inform a change in the status of an application. */
  90 // typedef enum { procPaused, procExited } processStatus_t;
  91 #define procPaused 0
  92 #define procExited 1
  93 typedef u_int processStatus_t;
  94
  95 $remote
  96 abstract class mdl_expr {
  97 $ignore
  98 public:
  99   virtual ~mdl_expr();
 100   virtual bool apply(mdl_var &ret) = 0;
 101   virtual bool mk_list(vector<string> &funcs) = 0;
 102 #ifdef NO_MDL_PRINT
 103   virtual void print(ostream& os) = 0;
 104 #endif
 105 $ignore
 106 };
 107
 108 $remote
 109 class mdl_v_expr : mdl_expr {
 110   string var_;
 111   vector<string> fields_;
 112   vector<mdl_expr*> *args_;
 113   int literal_;
 114   u_int arg_;
 115   mdl_expr *left_;
 116   mdl_expr *right_;
 117   u_int type_;
 118   vector<u_int> type_walk;
 119   bool do_type_walk_;
 120   bool ok_;
 121   u_int res_type_;
 122
 123 $ignore
 124 public:
 125   mdl_v_expr(string var, vector<string> fields);
 126   mdl_v_expr(string func_name, vector<mdl_expr*> *args);
 127   mdl_v_expr(int int_literal);
 128   mdl_v_expr(string string_lit);
 129   mdl_v_expr(u_int bin_op, mdl_expr *left, mdl_expr *right);
 130   mdl_v_expr(string var, u_int array_index);
 131   ~mdl_v_expr();
 132   bool apply(mdl_var &ret);
 133   bool mk_list(vector<string> &funcs);
 134 #ifdef NO_MDL_PRINT
 135   virtual void print(ostream& os) {
 136     os << "MDL_V_EXPR: var=" << var_ << " res_type=" << res_type_ << " do_type_walk="
 137       << do_type_walk_;
 138     unsigned size = fields_.size(), index;
 139     if (size) {
 140       os << "Fields: ";
 141       for (index=0; index<size; index++) {
 142         os << fields_[index] << " ";
 143       }
 144       os << endl;
 145     }
 146   }
 147 #endif
 148
 149 $ignore
 150 };
 151
 152 $remote
 153 abstract class mdl_rand {
 154 $ignore
 155 public:
 156   virtual ~mdl_rand() {}
 157   virtual bool apply(AstNode *&) = 0;
 158 $ignore
 159 };
 160
 161 $remote
 162 class mdl_instr_rand: mdl_rand {
 163   u_int type_;
 164   u_int val_;
 165   string name_;
 166   vector<mdl_rand *> args_;
 167 $ignore
 168 public:
 169   mdl_instr_rand(u_int type);
 170   mdl_instr_rand(u_int type, u_int val);
 171   mdl_instr_rand(u_int type, string name);
 172   mdl_instr_rand(u_int type, string name, vector<mdl_instr_rand *>args);
 173   ~mdl_instr_rand();
 174   virtual bool apply(AstNode *&);
 175 $ignore
 176 };
 177
 178 $remote
 179 class mdl_instr_req {
 180   u_int type_;
 181   mdl_instr_rand *rand_;
 182   string timer_counter_name_;
 183
 184 $ignore
 185 public:
 186   // start and stop timers, read symbol
 187   mdl_instr_req(u_int type, string name);
 188
 189   // for counters
 190   mdl_instr_req(mdl_instr_rand *arg, u_int type, string obj_name);
 191
 192   // for calls
 193   mdl_instr_req(u_int type, mdl_instr_rand *rand);
 194
 195  ~mdl_instr_req();
 196
 197    bool apply(AstNode *&mn, AstNode *pred, bool mn_initialized);
 198 $ignore
 199 };
 200
 201 $remote
 202 class mdl_icode {
 203   mdl_instr_rand *if_op1_;
 204   mdl_instr_rand *if_op2_;
 205   u_int bin_op_;
 206   bool use_if_;
 207   mdl_instr_req *req_;
 208
 209 $ignore
 210 public:
 211   mdl_icode(mdl_instr_rand *iop1, mdl_instr_rand *iop2,
 212             u_int bop, bool use, mdl_instr_req *r);
 213   ~mdl_icode();
 214    bool apply(AstNode *&mn, bool mn_initialized);
 215 $ignore
 216 };
 217
 218 $remote
 219 abstract class mdl_stmt {
 220 $ignore
 221 public:
 222   virtual ~mdl_stmt() { }
 223   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags) = 0;
 224   virtual bool mk_list(vector<string> &funcs) = 0;
 225 #ifdef NO_MDL_PRINT
 226   virtual void print(ostream& os) = 0;
 227 #endif
 228 $ignore
 229 };
 230
 231 $remote
 232 class mdl_list_stmt : mdl_stmt {
 233   u_int type_;
 234   string id_;
 235   vector<string> *elements_;
 236   bool is_lib_;
 237   vector<string> *flavor_;
 238
 239 $ignore
 240 public:
 241   mdl_list_stmt(u_int type, string ident, vector<string> *elems,
 242                 bool is_lib, vector<string> *flavor);
 243   virtual ~mdl_list_stmt();
 244   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
 245   virtual bool mk_list(vector<string> &funcs);
 246 #ifdef NO_MDL_PRINT
 247   virtual void print(ostream&) { }
 248 #endif
 249
 250 $ignore
 251 };
 252
 253 $remote
 254 class mdl_for_stmt : mdl_stmt {
 255   mdl_stmt *for_body_;
 256   string index_name_;
 257   mdl_expr *list_expr_;
 258
 259 $ignore
 260 public:
 261   mdl_for_stmt(string index_name, mdl_expr *list_exp, mdl_stmt *body);
 262   virtual ~mdl_for_stmt();
 263   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
 264   virtual bool mk_list(vector<string> &funcs);
 265 #ifdef NO_MDL_PRINT
 266   virtual void print(ostream&) { }
 267 #endif
 268
 269 $ignore
 270 };
 271
 272 $remote
 273 class mdl_if_stmt : mdl_stmt {
 274   mdl_expr *expr_;
 275   mdl_stmt *body_;
 276
 277 $ignore
 278 public:
 279   mdl_if_stmt(mdl_expr *expr, mdl_stmt *body);
 280   virtual ~mdl_if_stmt();
 281   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
 282   virtual bool mk_list(vector<string> &funcs);
 283 #ifdef NO_MDL_PRINT
 284   virtual void print(ostream&) { }
 285 #endif
 286
 287 $ignore
 288 };
 289
 290 $remote
 291 class mdl_seq_stmt : mdl_stmt {
 292   vector<mdl_stmt*> *stmts_;
 293
 294 $ignore
 295 public:
 296   mdl_seq_stmt(vector<mdl_stmt*> *stmts);
 297   virtual ~mdl_seq_stmt();
 298   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
 299   virtual bool mk_list(vector<string> &funcs);
 300 #ifdef NO_MDL_PRINT
 301   virtual void print(ostream&) { }
 302 #endif
 303
 304 $ignore
 305 };
 306
 307 $remote
 308 class mdl_instr_stmt : mdl_stmt {
 309   u_int position_; // append or prepend
 310   mdl_expr *point_expr_; // e.g. $start.entry.  Can be a fn entry, exit, or call site.
 311   vector<mdl_icode*> *icode_reqs_; // the instrumentation code itself
 312   u_int where_instr_; // preInsn or postInsn
 313   bool constrained_; // if not true, no constraints will be applied
 314
 315 $ignore
 316 public:
 317   mdl_instr_stmt(u_int pos, mdl_expr *point_expr, vector<mdl_icode*> *i_reqs,
 318                  unsigned where_instr, bool constrained);
 319   virtual ~mdl_instr_stmt();
 320   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
 321   virtual bool mk_list(vector<string> &funcs);
 322 #ifdef NO_MDL_PRINT
 323   virtual void print(ostream& os) {
 324     os << "MDL_INSTR_STMT: constrained=" << constrained_ << " ";
 325     point_expr_->print(os);
 326   }
 327 #endif
 328
 329 $ignore
 330 };
 331
 332 $remote
 333 class mdl_constraint {
 334   string id_;
 335   vector<string> *match_path_;
 336   vector<mdl_stmt*> *stmts_;
 337   bool replace_;
 338   u_int data_type_;
 339   u_int hierarchy_;
 340   u_int type_;
 341
 342 $ignore
 343 public:
 344   mdl_constraint(string id, vector<string> *match_path,
 345                  vector<mdl_stmt*> *stmts, bool replace, u_int d_type,
 346                  bool& error);
 347   ~mdl_constraint();
 348   bool apply(metricDefinitionNode *mn, dataReqNode *&flag,
 349              vector<string>& resource, process *proc, bool computingCost);
 350   bool mk_list(vector<string> &funcs);
 351
 352 #ifdef NO_MDL_PRINT
 353    friend ostream& operator<< (ostream& os, const mdl_constraint& cons) {
 354      os << "\nConstraint: " << cons.id_ << " ";
 355      unsigned size, index;
 356      if (cons.match_path_) {
 357        size = cons.match_path_->size();
 358        for (index=0; index<size; index++) os << (*cons.match_path_)[index] << "/";
 359        os << endl;
 360      }
 361      os << "Replace=" << cons.replace_ << " Data_type=" << cons.data_type_ << " Hierarchy="
 362        << cons.hierarchy_ << " Type=" << cons.type_ << endl;
 363     if (cons.stmts_) {
 364       size = cons.stmts_->size();
 365       os << "Statements\n";
 366       for (index=0; index<size; index++) {
 367         (*cons.stmts_)[index]->print(os);
 368         os << " ";
 369       }
 370     }
 371     return os;
 372    }
 373 #endif
 374
 375 $ignore
 376 };
 377
 378 $remote
 379 class mdl_metric {
 380   string id_;
 381   string name_;
 382   string units_;
 383   u_int agg_op_; // avg, sum, min, or max
 384   u_int style_;  // currently, always EventCounter
 385   u_int type_;   // counter, processTimer, or wallTimer
 386   vector<mdl_stmt*> *stmts_; // for "base is <type_> { ... } (is this correct?)
 387   vector<string> *flavors_; // which flavors this metric is valid for
 388   vector<mdl_constraint*> *constraints_;
 389   vector<string> *temp_ctr_; // temporary counters
 390   bool developerMode_;
 391   int unitstype_; // normalized, unnormalized, or sampled
 392
 393 $ignore
 394 public:
 395   mdl_metric(string id, string name, string units,
 396              u_int agg, u_int style, u_int type,
 397              vector<mdl_stmt*> *mv, vector<string> *flavs,
 398              vector<mdl_constraint*> *cons,
 399              vector<string> *temp_c, bool developerMode,int unitstype);
 400   ~mdl_metric();
 401 #ifdef NO_MDL_PRINT
 402   friend ostream& operator<< (ostream &os, const mdl_metric& met) {
 403     os << "\nMetric: " << met.id_ << " " << met.name_ << " agg_op=" << met.agg_op_ << " style="
 404       << met.style_ << " type=" << met.type_ << endl;
 405     unsigned size, index;
 406     if (met.stmts_) {
 407       size = met.stmts_->size();
 408       os << "Statements\n";
 409       for (index=0; index<size; index++) {
 410         (*met.stmts_)[index]->print(os);
 411          os << " ";
 412       }
 413     }
 414     if (met.constraints_) {
 415       size = met.constraints_->size();
 416       os << "Constraints\n";
 417       for (index=0; index<size; index++) {
 418         os << *((*met.constraints_)[index]) << " ";
 419       }
 420     }
 421     return os;
 422   }
 423 #endif
 424   metricDefinitionNode *apply(vector< vector<string> >&focus,
 425                               string& flat_name,
 426                               vector<process *> procs,
 427                               bool replace_components_if_present,
 428                               bool computingCost);
 429 $ignore
 430 };
 431
 432 /* descriptive information about a metric */
 433 $remote struct metricInfo {
 434     string name;
 435     int style;
 436     int aggregate;
 437     string units;
 438     bool developerMode;
 439     int unitstype;
 440     u_int handle;  // this is currently ignored by the daemons
 441 };
 442
 443 $remote struct focusStruct {
 444   vector<u_int> focus;
 445 };
 446
 447 $remote struct resourceInfoCallbackStruct {
 448    u_int temporaryId;
 449    vector<string> resource_name;
 450    string abstraction;
 451    u_int type;
 452 };
 453
 454 /*
 455  * Create a paradynd process.
 456  *
 457  */
 458 int createDaemon(string machine,
 459                  string login,
 460                  string name,
 461                  vector<string> argv);
 462
 463
 464 $remote dynRPC {
 465     $base 4000;
 466     $version 52;
 467
 468     //
 469     // Define a program to run.
 470     // argv: the command and arguments
 471     // dir: working directory where program will run.
 472     int addExecutable(vector<string> argv, string dir);
 473
 474     //
 475     // Connect up with a running program (not possible on all platforms).
 476     // 'path' gives the full path name to the executable, used only to read
 477     // the symbol table.
 478     // values for 'afterAttach': 1 --> pause, 2 --> run, 0 --> leave as is
 479     //
 480     bool attach(string path, int pid, int afterAttach);
 481
 482     //
 483     // Start an application running (This starts the actual execution).
 484     //
 485     bool startProgram(int program);
 486
 487     //
 488     //   Stop a process
 489     //
 490     bool pauseProgram(int program);
 491
 492     //
 493     //   Stop all processes associted with the application.
 494     //
 495     bool pauseApplication();
 496
 497     //
 498     // Continue a paused process
 499     //
 500     void continueProgram(int program);
 501
 502     //
 503     // Continue all of the processes
 504     //
 505     void continueApplication();
 506
 507     //
 508     // Disconnect the tool from the process.
 509     //    pause - leave the process in a stopped state.
 510     //
 511     //
 512     bool detachProgram(int program, bool pause);
 513
 514     //
 515     // Called by paradynd when a new process starts up.  Specifically, paradynd
 516     // calls it when it detects that the new program has finished running
 517     // its DYNINST().
 518     //
 519     // If the state of the appl as a whole is 'running' then we (paradyn) will
 520     // issue an igen call to continue this new process; otherwise, we'll leave it
 521     // paused.
 522     //
 523     $upcall $async void newProgramCallbackFunc( int pid,
 524                                                 vector<string> argv,
 525                                                 string machine,
 526                                                 bool calledFromExec,
 527                                                 bool wantToInitiallyRun);
 528     //
 529     // Message display with "error" visual characteristics
 530     // and lookup in error database for explanation. This function
 531     // calls showError function in UIM class
 532     //
 533     $upcall $async void showErrorCallback (int errCode,
 534                                            string errString,
 535                                            string hostName);
 536
 537    // batch the samples (paradynd-->paradyn) to get better performance
 538    // the functionality is essentially the same as the
 539    // sampleDataCallbackFunc, which is now obsolete
 540
 541    $virtual $upcall $async
 542    void batchSampleDataCallbackFunc(int program,
 543                                     vector<batch_buffer_entry> theBatchBuffer);
 544
 545    // batch the traces (paradynd-->paradyn) to get better performance
 546    // the functionality is essentially the same as the
 547    // batchSampleDataCallbackFunc, which is now obsolete
 548
 549    $virtual $upcall $async
 550    void batchTraceDataCallbackFunc(int program,
 551                                     vector<trace_batch_buffer_entry> theTraceBatchBuffer);
 552
 553    //
 554    // XXXX - Hack this should be generalized into a vector.
 555    //
 556    $virtual $upcall $async void cpDataCallbackFunc(int program,
 557                                                       double timeStamp,
 558                                                       int context,
 559                                                       double total,
 560                                                       double share);
 561
 562    //
 563    // Handler that reports the initial time for which a daemon reports a sample
 564    // The earliest (absolute) initial time will become the base time (0)
 565    //
 566    $virtual $upcall $async void firstSampleCallback(int program,
 567                                                     double time);
 568
 569     //
 570     // Handler that gets called when a new resource is defined.
 571     //
 572     // temporaryId      - daemon generated resource id (it will become the
 573     //                          permanent id, unless there are conflicts
 574     //                          with id's generated by another daemon)
 575     // resource_name    - name of resource, divided into parts
 576     // abstraction      - abstraction to which it belongs
 577     // type             - the MDL type for this resource (MDL_T_STRING, etc.)
 578     //
 579     $virtual $upcall $async void resourceInfoCallback(u_int temporaryId,
 580                                              vector<string> resource_name,
 581                                              string abstraction, u_int type);
 582
 583     $virtual $upcall $async void severalResourceInfoCallback(vector<resourceInfoCallbackStruct>);
 584
 585    //
 586     // Handler that gets called when a new memory is defined.
 587     //
 588     // data_structure   - name of memory chunk, divided into blks
 589     // virtual_address  - start address of the memory chunk
 590     // memory_size      - size of the memory chunk
 591     // blk_size         - block size
 592     $upcall $async void memoryInfoCallback(int program,
 593                                            string data_structure,
 594                                            int virtual_address,
 595                                            u_int memory_size,
 596                                            u_int blk_size) ;
 597
 598     // In case there are conflicts between the resource Id's generated by
 599     // the daemons, paradyn generates a new Id and report it to the daemon.
 600     $async void resourceInfoResponse(vector<u_int> temporaryIds,
 601                                      vector<u_int>resourceIds);
 602
 603
 604     // The ids that will be used to represent memory resources
 605     // see memoryInfoCallback
 606     $async void memoryInfoResponse(string data_structure,
 607                                    int virtual_address,
 608                                    u_int memory_size,
 609                                    u_int blk_size,
 610                                    vector<u_int> resource_ids) ;
 611
 612     $async void memoryRangeSelected(string flat, int min, int max) ;
 613
 614     $virtual $upcall $async void resourceBatchMode(bool);
 615
 616     //
 617     // Handler that gets called when new mapping data is collected.
 618     //
 619     $upcall $async void mappingInfoCallback(int program,
 620                                             string abstraction,
 621                                             string type,
 622                                             string key,
 623                                             string value);
 624
 625     // Upcall for a new metric being defined.
 626     //
 627     $upcall $async void newMetricCallback(metricInfo info);
 628
 629     void setSampleRate(double sampleInterval);
 630
 631     //
 632     // tell dyninst to ignore this resource for instrumentation.
 633     //    Currently this only applies to programs, modules, and procedures.
 634     //    False - suppress
 635     //    True - enable
 636     //
 637     bool setTracking(u_int resource_id, bool);
 638
 639     //
 640     // Routines to control data collection on a performanceStream.
 641     //
 642     // resourceList     - a list of resources
 643     // metric   - what metric to collect data for
 644     //
 645     $async void enableDataCollection(vector<focusStruct> focus,
 646                                       vector<string> metric,
 647                                       vector<u_int> mi_ids,
 648                                       u_int daemon_id,
 649                                       u_int request_id);
 650     //
 651     // synchronous enable call, for propogating metrics
 652     //
 653     int enableDataCollection2(vector<u_int> focus, string metric, int id);
 654
 655     //
 656     // Upcall to tell paradyn that all daemons are ready after a metric
 657     // enable request
 658     //
 659     $upcall $async void enableDataCallback(u_int daemon_id,
 660                                            vector<int> return_id,
 661                                            vector<u_int> mi_ids,
 662                                            u_int request_id);
 663     //
 664     // Upcall to tell paradyn that all daemons are ready after computing
 665     // the value for predicted data cost
 666     //    id: an identifier for the request
 667     //  client_id: an id passed by calling thread
 668     //
 669     $upcall $async void getPredictedDataCostCallback(u_int id,
 670                                                      u_int req_id,
 671                                                      float val,
 672                                                      u_int clientID);
 673
 674     //
 675     // stop collecting data for the named mi.
 676     //     mi           - a metricInstance returned by enableDataCollection.
 677     //
 678     $async void disableDataCollection(int mi);
 679
 680     //
 681     // called by a daemon when there is no more data to be sent for a metric
 682     // instance, because all processes have exited.
 683     $virtual $upcall $async void endOfDataCollection(int mi);
 684
 685     //
 686     // Return the expected cost of collecting performance data for a single
 687     //    metric at a given focus.  The value returned is the fraction of
 688     //    perturbation expected (i.e. 0.10 == 10% slow down expected).
 689     //    id: an identifier for the request
 690     //  client_id: an id passed by calling thread
 691     //
 692     $async void getPredictedDataCost(u_int id,
 693                                      u_int req_id,
 694                                      vector<u_int> focus,
 695                                      string metric,
 696                                      u_int clientID);
 697
 698     //
 699     // Get the static configuration information.
 700     //
 701     vector<metricInfo> getAvailableMetrics();
 702
 703     //
 704     // Create a new resource.
 705     //
 706     void addResource(u_int parent, u_int id, string name, u_int type);
 707
 708     //
 709     // stdio or stderr from an application.
 710     //
 711     $upcall $async void applicationIO(int pid, int len, string line);
 712
 713     //
 714     // stdio or stderr from an application.
 715     //
 716     $virtual $upcall $async void reportStatus(string line);
 717
 718     //
 719     // Debugger style calls.
 720     //
 721     //
 722     string getStatus(int pid);
 723     void coreProcess(int pid);
 724
 725     //
 726     // For paradynd's that may get started, but not by paradyn
 727     // This allows them to report system information
 728     // flavor = programming environment {"pvm", "cm5", ... }
 729     $virtual $upcall $async void reportSelf(string machine,
 730                                             string program,
 731                                             int pid,
 732                                             string flavor);
 733
 734     //
 735     // this call is used by paradynd to inform paradyn of a change in
 736     // the status of a process -- the process stops (due to a signal),
 737     // or the process exits
 738     //
 739     $virtual $upcall $async void processStatus(int pid, u_int procstat);
 740
 741     //
 742     // For timing and other measurements of paradynd
 743     //
 744     void printStats();
 745
 746     // MDL methods
 747     $async void send_metrics(vector<mdl_metric*> *);
 748     $async void send_constraints(vector<mdl_constraint*>*);
 749     $async void send_stmts(vector<mdl_stmt*> *);
 750     $async void send_libs(vector<string>*);
 751     $async void send_no_libs();
 752
 753     // get the current wall clock time of the daemon to adjust for clock differences
 754     double getTime();
 755
 756 };