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