added mdl classes
[dyninst.git] / paradyn / h / dyninstRPC.I
1 /*
2  * Copyright (c) 1993, 1994 Barton P. Miller, Jeff Hollingsworth,
3  *     Bruce Irvin, Jon Cargille, Krishna Kunchithapadam, Karen
4  *     Karavanic, Tia Newhall, Mark Callaghan.  All rights reserved.
5  * 
6  * This software is furnished under the condition that it may not be
7  * provided or otherwise made available to, or used by, any other
8  * person, except as provided for by the terms of applicable license
9  * agreements.  No title to or ownership of the software is hereby
10  * transferred.  The name of the principals may not be used in any
11  * advertising or publicity related to this software without specific,
12  * written prior authorization.  Any use of this software must include
13  * the above copyright notice.
14  *
15  */
16
17 /*
18  * $Log: dyninstRPC.I,v $
19  * Revision 1.26  1995/05/18 10:51:49  markc
20  * added mdl classes
21  * modified resource specifications in interfaces to use ids
22  *
23  * Revision 1.25  1995/02/16  08:01:42  markc
24  * Modified interfaces:
25  *   1) XDR interfaces use strings and vectors instead of igen arrays and char*'s
26  *   2) No sync upcalls are allowed by the server in xdr interfaces
27  *   3) Redefined igen arrays that were used in thread code to use manually defined
28  *      structures rather than igen-defined, since igen did not need to know about
29  *      these structures.
30  *   4) Upped all of the version numbers since all new interface code is generated
31  *   5) Async calls are no longer handled while waiting for sync responses, these
32  *      requests are buffered.
33  *
34  * Revision 1.24  1994/11/09  18:38:36  rbi
35  * the "Don't Blame Me" commit
36  *
37  * Revision 1.23  1994/11/03  16:05:31  rbi
38  * eliminated argc from addExecutable interface
39  *
40  * Revision 1.22  1994/11/02  11:41:27  markc
41  * Incremented the version.
42  *
43  * Revision 1.21  1994/09/22  00:44:26  markc
44  * Incremented version number
45  * Changed "String" to "char*"
46  * Made array declarations explicit
47  *
48  * Revision 1.20  1994/08/22  16:01:31  markc
49  * Remove my_pid which duplicated a class member
50  * Add daemon dictionary calls to dataManager interface.
51  *
52  * Revision 1.19  1994/08/17  17:55:27  markc
53  * Incremented version numbers because a new version of igen has been
54  * committed.
55  *
56  * Revision 1.18  1994/08/08  20:14:56  hollings
57  * added suppress instrumentation command.
58  *
59  * Revision 1.17  1994/07/20  16:30:40  hollings
60  * added resourceBatchMode
61  *
62  * Revision 1.16  1994/07/14  23:44:29  hollings
63  * added getCurrentHybridCost
64  *
65  * Revision 1.15  1994/07/05  03:26:54  hollings
66  * added stat printing command.
67  *
68  * Revision 1.14  1994/07/02  01:45:24  markc
69  * Removed aggregation operator from enableDataCollection call.
70  * Remove aggregation operator definitions, which are provided by
71  * util/h/aggregation.H
72  *
73  * Revision 1.13  1994/06/29  02:55:34  hollings
74  * Added copyright and log line.
75  *
76  *
77  */
78
79 #define MetStyleEventCounter    0
80 #define MetStyleSampledFunction 1
81
82 #include "util/h/Types.h"
83 #include "util/h/aggregation.h"
84 #include "paradyn/src/met/mdl.h"
85
86 $remote
87 abstract class mdl_expr {
88 $ignore
89 public:
90   virtual ~mdl_expr();
91   virtual bool apply(mdl_var &ret) = 0;
92 #ifdef NO_MDL_PRINT
93   virtual void print(ostream& os) = 0;
94 #endif
95 $ignore
96 };
97
98 $remote
99 class mdl_v_expr : mdl_expr {
100   string var_;
101   vector<string> fields_;
102   vector<mdl_expr*> *args_;
103   int literal_;
104   u_int arg_;
105   mdl_expr *left_;
106   mdl_expr *right_;
107   u_int type_;
108   vector<u_int> type_walk;
109   bool do_type_walk_;
110   bool ok_;
111   u_int res_type_;
112
113 $ignore
114 public:
115   mdl_v_expr(string var, vector<string> fields);
116   mdl_v_expr(string func_name, vector<T_dyninstRPC::mdl_expr*> *args);
117   mdl_v_expr(int int_literal);
118   mdl_v_expr(string string_lit);
119   mdl_v_expr(u_int bin_op, T_dyninstRPC::mdl_expr *left, T_dyninstRPC::mdl_expr *right);
120   mdl_v_expr(string var, u_int array_index);
121   ~mdl_v_expr();
122   bool apply(mdl_var &ret);
123 #ifdef NO_MDL_PRINT
124   virtual void print(ostream& os) {
125     os << "MDL_V_EXPR: var=" << var_ << " res_type=" << res_type_ << " do_type_walk="
126       << do_type_walk_;
127     unsigned size = fields_.size(), index;
128     if (size) {
129       os << "Fields: ";
130       for (index=0; index<size; index++) {
131         os << fields_[index] << " ";
132       }
133       os << endl;
134     }
135   }
136 #endif
137
138 $ignore
139 };
140
141 $remote
142 class mdl_instr_req {
143   u_int arg_type_;
144   u_int arg_val_;
145   string arg_name_;
146   string arg_name_2_;
147   u_int type_;
148   string timer_counter_name_;
149
150 $ignore
151 public:
152   // start and stop timers, read symbol
153   mdl_instr_req(u_int type, string name);
154
155   // for counters, call_func
156   mdl_instr_req(u_int arg_type, u_int arg_val, string arg_name, string arg_name_2,
157                 u_int type, string obj_name);
158
159   ~mdl_instr_req();
160   bool apply(u_int pos, instPoint *p, u_int where_instr, metricDefinitionNode *m,
161              AstNode *pred, vector<dataReqNode*>& flags);
162 $ignore
163 };
164
165 $remote
166 class mdl_icode {
167   u_int if_op1_;
168   u_int if_val1_;
169   string if_str1_;
170
171   u_int if_op2_;
172   u_int if_val2_;
173   string if_str2_;
174
175   u_int bin_op_;
176   bool use_if_;
177   mdl_instr_req *req_;
178
179 $ignore
180 public:
181   mdl_icode(u_int iop1, u_int ival1, string str1,
182             u_int iop2, u_int ival2, string str2,
183             u_int bop, bool use, T_dyninstRPC::mdl_instr_req *r);
184   ~mdl_icode();
185   bool apply(u_int position, instPoint *p, u_int where_instr,
186              metricDefinitionNode *mn, vector<dataReqNode*>& flags);
187 $ignore
188 };
189
190 $remote
191 abstract class mdl_stmt {
192 $ignore
193 public:
194   virtual ~mdl_stmt() { }
195   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags) = 0;
196 #ifdef NO_MDL_PRINT
197   virtual void print(ostream& os) = 0;
198 #endif
199 $ignore
200 };
201
202 $remote
203 class mdl_list_stmt : mdl_stmt {
204   u_int type_;
205   string id_;
206   vector<string> *elements_;
207   bool is_lib_;
208   string flavor_;
209
210 $ignore
211 public:
212   mdl_list_stmt(u_int type, string ident, vector<string> *elems,
213                 bool is_lib, string flavor);
214   virtual ~mdl_list_stmt();
215   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
216 #ifdef NO_MDL_PRINT
217   virtual void print(ostream& os) { }
218 #endif
219
220 $ignore
221 };
222
223 $remote
224 class mdl_for_stmt : mdl_stmt {
225   mdl_stmt *for_body_;
226   string index_name_;
227   mdl_expr *list_expr_;
228
229 $ignore
230 public:
231   mdl_for_stmt(string index_name, T_dyninstRPC::mdl_expr *list_exp, mdl_stmt *body);
232   virtual ~mdl_for_stmt();
233   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
234 #ifdef NO_MDL_PRINT
235   virtual void print(ostream& os) { }
236 #endif
237
238 $ignore
239 };
240
241 $remote
242 class mdl_if_stmt : mdl_stmt {
243   mdl_expr *expr_;
244   mdl_stmt *body_;
245
246 $ignore
247 public:
248   mdl_if_stmt(mdl_expr *expr, mdl_stmt *body);
249   virtual ~mdl_if_stmt();
250   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
251 #ifdef NO_MDL_PRINT
252   virtual void print(ostream& os) { }
253 #endif
254
255 $ignore
256 };
257
258 $remote
259 class mdl_seq_stmt : mdl_stmt {
260   vector<mdl_stmt*> *stmts_;
261
262 $ignore
263 public:
264   mdl_seq_stmt(vector<mdl_stmt*> *stmts);
265   virtual ~mdl_seq_stmt();
266   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
267 #ifdef NO_MDL_PRINT
268   virtual void print(ostream& os) { }
269 #endif
270
271 $ignore
272 };
273
274 $remote
275 class mdl_instr_stmt : mdl_stmt {
276   u_int position_;
277   mdl_expr *point_expr_;
278   vector<mdl_icode*> *icode_reqs_;
279   u_int where_instr_;
280   bool constrained_;
281
282 $ignore
283 public:
284   mdl_instr_stmt(u_int pos, mdl_expr *point_expr, vector<mdl_icode*> *i_reqs,
285                  unsigned where_instr, bool constrained);
286   virtual ~mdl_instr_stmt();
287   virtual bool apply(metricDefinitionNode *mn, vector<dataReqNode*>& flags);
288 #ifdef NO_MDL_PRINT
289   virtual void print(ostream& os) {
290     os << "MDL_INSTR_STMT: constrained=" << constrained_ << " ";
291     point_expr_->print(os);
292   }
293 #endif
294
295 $ignore
296 };
297
298 $remote 
299 class mdl_constraint {
300   string id_;
301   vector<string> *match_path_;
302   vector<mdl_stmt*> *stmts_;
303   bool replace_;
304   u_int data_type_;
305   u_int hierarchy_;
306   u_int type_;
307
308 $ignore
309 public:
310   mdl_constraint(string id, vector<string> *match_path,
311                  vector<T_dyninstRPC::mdl_stmt*> *stmts, bool replace, u_int d_type,
312                  bool& error);
313   ~mdl_constraint();
314   bool apply(metricDefinitionNode *mn, dataReqNode *&flag,
315              vector<string>& resource, process *proc);
316
317 #ifdef NO_MDL_PRINT
318    friend ostream& operator<< (ostream& os, const T_dyninstRPC::mdl_constraint& cons) {
319      os << "\nConstraint: " << cons.id_ << " ";
320      unsigned size, index;
321      if (cons.match_path_) {
322        size = cons.match_path_->size();
323        for (index=0; index<size; index++) os << (*cons.match_path_)[index] << "/";
324        os << endl;
325      }
326      os << "Replace=" << cons.replace_ << " Data_type=" << cons.data_type_ << " Hierarchy=" 
327        << cons.hierarchy_ << " Type=" << cons.type_ << endl;
328     if (cons.stmts_) {
329       size = cons.stmts_->size();
330       os << "Statements\n";
331       for (index=0; index<size; index++) {
332         (*cons.stmts_)[index]->print(os);
333         os << " ";
334       }
335     }
336    }
337 #endif
338
339 $ignore
340 };
341
342 $remote
343 class mdl_metric {
344   string id_;
345   string name_;
346   string units_;
347   u_int fold_op_;
348   u_int agg_op_;
349   u_int style_;
350   u_int type_;
351   vector<mdl_stmt*> *stmts_;
352   vector<string> *flavors_;
353   vector<mdl_constraint*> *constraints_;
354   vector<string> *temp_ctr_;
355
356 $ignore
357 public:
358   mdl_metric(string id, string name, string units,
359              u_int fold, u_int agg, u_int style, u_int type,
360              vector<mdl_stmt*> *mv, vector<string> *flavs, vector<T_dyninstRPC::mdl_constraint*> *cons,
361              vector<string> *temp_c);
362   ~mdl_metric();
363 #ifdef NO_MDL_PRINT
364   friend ostream& operator<< (ostream &os, const T_dyninstRPC::mdl_metric& met) {
365     os << "\nMetric: " << met.id_ << " " << met.name_ << " agg_op=" << met.agg_op_ << " style=" 
366       << met.style_ << " type=" << met.type_ << endl;
367     unsigned size, index;
368     if (met.stmts_) {
369       size = met.stmts_->size();
370       os << "Statements\n";
371       for (index=0; index<size; index++) {
372         (*met.stmts_)[index]->print(os);
373          os << " ";
374       }
375     }
376     if (met.constraints_) {
377       size = met.constraints_->size();
378       os << "Constraints\n";
379       for (index=0; index<size; index++) {
380         os << *((*met.constraints_)[index]) << " ";
381       }
382     }
383   }
384 #endif
385   metricDefinitionNode *apply(vector< vector<string> >&focus, string& flat_name);
386 $ignore
387 };
388
389 /* descriptive information about a metric */
390 $remote struct metricInfo { 
391     string name;
392     int style;
393     int aggregate;
394     string units;
395 };
396
397 /*
398  * Create a paradynd process.
399  *
400  */
401 int createDaemon(string machine,
402                  string login,
403                  string name,
404                  vector<string> argv);
405
406
407 $remote dynRPC {
408     $base 4000;
409     $version 21;
410
411     //
412     // Define a program to run. 
413     int addExecutable(vector<string> argv);
414
415     //
416     // Connect up with a running program (not possible on all platforms).
417     //
418     bool attachProgram(int pid);
419
420     //
421     // Start an application running (This starts the actual execution).
422     //
423     bool startProgram(int program);
424
425     //
426     //   Stop a process
427     //
428     bool pauseProgram(int program);
429
430     //
431     //   Stop all processes associted with the application.
432     //
433     bool pauseApplication();
434
435     //
436     // Continue a paused process
437     //
438     void continueProgram(int program);
439
440     //
441     // Continue all of the processes
442     //
443     void continueApplication();
444
445     //
446     // Disconnect the tool from the process.
447     //    pause - leave the process in a stopped state.
448     //
449     //
450     bool detachProgram(int program, bool pause);
451
452     //
453     // Gets called when a new application is started that is not visible to
454     //   paradyn (e.g. pvm_spawn).
455     //
456     $upcall $async void newProgramCallbackFunc( int pid, 
457                                                 vector<string> argv, 
458                                                 string machine);
459                                 
460
461     //
462     // Handler that gets called when new sample data is delivered.
463     //
464     //   p - a program from addProgram
465     //   mi - a metricInstance returned by enableDataCollection
466     //   startTimeStamp - starting time of the interval covered by this sample.
467     //   endTimeStamp - ending time of the interval covered by this sample.
468     //   value - the value of this sample
469     //
470    $virtual $upcall $async void sampleDataCallbackFunc(int program, 
471                                                        int mi,
472                                                        double startTimeStamp, 
473                                                        double endTimeStamp, 
474                                                        double value);
475
476    // 
477    // Handler that reports the initial time for which a daemon reports a sample
478    // The earliest (absolute) initial time will become the base time (0)
479    //
480    $virtual $upcall $async void firstSampleCallback(int program,
481                                                     double time);
482
483     //
484     // Handler that gets called when a new resource is defined.
485     //
486     // resource_name    - name of resource, divided into parts
487     // abstraction      - abstraction to which it belongs     
488     //
489     $upcall $async void resourceInfoCallback(int program, 
490                                              vector<string> resource_name,
491                                              string abstraction);
492
493     // The id that will be used to represent this resource
494     $async void resourceInfoResponse(vector<string> resource_name, u_int resource_id);
495
496     $upcall $async void resourceBatchMode(bool);
497
498     //
499     // Handler that gets called when new mapping data is collected.
500     //
501     $upcall $async void mappingInfoCallback(int program, 
502                                             string abstraction, 
503                                             string type, 
504                                             string key,
505                                             string value);
506
507     // Upcall for a new metric being defined.
508     //
509     $upcall $async void newMetricCallback(metricInfo info); 
510
511     void setSampleRate(double sampleInterval);
512
513     //
514     // tell dyninst to ignore this resource for instrumentation.
515     //    Currently this only applies to programs, modules, and procedures.
516     //    False - suppress
517     //    True - enable
518     //
519     bool setTracking(u_int resource_id, bool);
520
521     //
522     // Routines to control data collection on a performanceStream.
523     //
524     // resourceList     - a list of resources
525     // metric   - what metric to collect data for
526     //
527     int enableDataCollection(vector<u_int> focus, string metric);
528
529     //
530     // stop collecting data for the named mi.
531     //     mi           - a metricInstance returned by enableDataCollection.
532     //
533     void disableDataCollection(int mi);
534
535     //
536     // Return the expected cost of collecting performance data for a single
537     //    metric at a given focus.  The value returned is the fraction of
538     //    perturbation expected (i.e. 0.10 == 10% slow down expected).
539     //
540     double getPredictedDataCost(vector<u_int> focus, string metric);
541
542     //
543     // Current best guess about the cost of instrumentation.
544     //
545     double getCurrentHybridCost();
546
547     //
548     // Get the static configuration information.
549     //
550     vector<metricInfo> getAvailableMetrics();
551
552     //
553     // Create a new resource.
554     //
555     void addResource(u_int parent, u_int id, string name);
556
557     //
558     // stdio or stderr from an application.
559     //
560     $upcall $async void applicationIO(int pid, int len, string line);
561
562     //
563     // stdio or stderr from an application.
564     //
565     $virtual $upcall $async void reportStatus(string line);
566
567     //
568     // Debugger style calls.
569     //
570     //
571     string getStatus(int pid);
572     void coreProcess(int pid);
573
574     //
575     // For paradynd's that may get started, but not by paradyn
576     // This allows them to report system information
577     // flavor = programming environment {"pvm", "cm5", ... }
578     $virtual $upcall $async void reportSelf(string machine, 
579                                             string program, 
580                                             int pid,
581                                             string flavor);
582
583     //
584     // For timing and other measurements of paradynd
585     //
586     void printStats();
587
588     // MDL methods
589     $async void send_metrics(vector<mdl_metric*> *);
590     $async void send_constraints(vector<mdl_constraint*>*);
591     $async void send_stmts(vector<mdl_stmt*> *);
592 };