Added checks in bundlers. Fixed xdrrec_endofrecord.
[dyninst.git] / paradyn / h / dataManager.I
1 /*
2  * dataManager.h - exported services of the Data Mgr thread of paradyn.
3  *
4  * $Log: dataManager.I,v $
5  * Revision 1.7  1994/03/31 01:37:21  markc
6  * added pause/continue Process.
7  *
8  * Revision 1.6  1994/03/20  01:48:51  markc
9  * Added support for paradyn daemon name.  igen function to store name.
10  *
11  * Revision 1.5  1994/03/08  17:39:23  hollings
12  * Added foldCallback and getResourceListName.
13  *
14  * Revision 1.4  1994/02/24  04:34:14  markc
15  * Added an upcall to dyninstRPC.I to allow paradynd's to report information at
16  * startup.  Added a data member to the class that igen generates.
17  *
18  * Revision 1.3  1994/02/03  23:26:50  hollings
19  * Changes to work with g++ version 2.5.2.
20  *
21  * Revision 1.2  1994/02/01  18:47:33  hollings
22  * Upgrades for performanceConsultant thread.
23  *
24  * Revision 1.1  1994/01/27  00:41:37  hollings
25  * First version of data manager interfaces.
26  *
27  */
28
29 #ifndef MMTHREAD_H
30 #define MMTHREAD_H
31
32 #include "util/h/list.h"
33 #include "rtinst/h/trace.h"
34 #include "util/h/hist.h"
35 #include "dyninstRPC.h"
36
37 /* one or more program working together */
38 class applicationContext;       
39
40 /* sequence of peformance data (trace|sample) */
41 class performanceStream;        
42
43 /* time */
44 // typedef double timeStamp;            
45
46 /* something that data can be collected for */
47 class resource;         
48
49 /* descriptive information about a resource */
50 typedef struct {
51     char *name;                 /* name of actual resource */
52     char *fullName;             /* full path name of resource */
53     timeStamp creation;         /* when did it get created */
54 } resourceInfo;         
55
56 /* list of resources */
57 class resourceList;             
58
59 /* a metric */
60 class metric;                   
61
62 /* a list of metrics */
63 typedef metric *metricList;             
64
65 /* a metric/resourceList pair */
66 class metricInstance;           
67
68 typedef enum { Trace, Sample } dataType;
69
70 /*
71  * error handler call back.
72  *
73  */
74 typedef (*errorHandler)(int errno, char *message);
75
76 /*
77  * Handler that gets called when new sample data is delivered.
78  *
79  *   ps - a performanceStream from createPerformanceStream
80  *   mi - a metricInstance returned by enableDataCollection
81  *   startTimeStamp - starting time of the interval covered by this sample.
82  *   endTimeStamp - ending time of the interval covered by this sample.
83  *   value - the value of this sample
84  *    
85  */
86 typedef (*sampleDataCallbackFunc)(performanceStream *ps, 
87                                   metricInstance *mi,
88                                   timeStamp startTimeStamp, 
89                                   timeStamp endTimeStamp, 
90                                   sampleValue value);
91
92 /*
93  * Handler that gets called when new trace data is available.
94  *   
95  *   ps - a performanceStream from createPerformanceStream
96  *   mi - a metricInstance returned by enableDataCollection
97  *   time - time of the event.
98  *   eventSize - size of the event specific data.
99  *   eventData - event specific data.
100  */
101 typedef (*traceDataCallbackFunc)(performanceStream *ps, metricInstance *mi,
102     timeStamp time, int eventSize, void *eventData);
103
104 /*
105  * union to hold two types of data callback.
106  *
107  */
108 union dataCallback {
109     sampleDataCallbackFunc      sample;
110     traceDataCallbackFunc       trace;
111 };
112
113 typedef union dataCallback dataCallback;
114
115 /*
116  * Handler that gets called when a new metric is defined.
117  *
118  * performanceStream    - a stream returned by createPerformanceStream
119  * metric               - a metric
120  *
121  */
122 typedef void (*metricInfoCallback)(performanceStream*, metric*);
123
124 /*
125  * Handler that gets called when a new resource is defined.
126  *
127  * performanceStream    - a stream returned by createPerformanceStream
128  * parent               - parent of new resource
129  * newResource          - new resource being created
130  * name                 - name of the new resource
131  *
132  */
133 typedef void (*resourceInfoCallback)(performanceStream*, resource *parent, 
134     resource *newResource, char *name);
135
136 typedef void (*histFoldCallback)(performanceStream*, timeStamp width);
137
138 struct controlCallback {
139     metricInfoCallback          mFunc;
140     resourceInfoCallback        rFunc;
141     histFoldCallback            fFunc;
142 };
143
144 typedef struct controlCallback controlCallback;
145
146
147 $remote dataManager {
148     $base 2000;
149     $version 3;
150
151     //
152     // Create an applicationContext (an application to be studied)
153     //
154     applicationContext *createApplicationContext(errorHandler foo);
155
156     //
157     // Define a program to run. 
158     //
159     Boolean addExecutable(applicationContext *app,
160                           char  *machine, 
161                           char *login, 
162                           char *name, 
163                           int argc,
164                           char **argv);
165
166     //
167     // Find out if an application has been defined yet.
168     //
169     Boolean applicationDefined(applicationContext *app);
170
171     //
172     // Start an application running (This starts the actual execution).
173     //   app - an application context from createPerformanceConext.
174     // 
175     Boolean startApplication(applicationContext *app);
176
177     //
178     //   Stop all processes associted with the application.
179     //      app - an application context from createPerformanceConext.
180     //
181     // Pause an application (I am not sure about this but I think we want it).
182     //      - Does this force buffered data to be delivered?
183     //  - Does a paused application respond to enable/disable commands?
184     //
185     Boolean pauseApplication(applicationContext *app);
186
187     //
188     //   Stop all processes associted with the application.
189     //      app - an application context from createPerformanceConext.
190     //
191     // Pause a process in an application 
192     //      - Does this force buffered data to be delivered?
193     //  - Does a paused application respond to enable/disable commands?
194     //
195     Boolean pauseProcess(applicationContext *app, int pid);
196
197     //
198     //
199     // Continue a paused application.
200     //    app - an application context from createPerformanceConext.
201     //
202     Boolean continueApplication(applicationContext *app);
203
204     //
205     // Continue a paused process in an application.
206     //    app - an application context from createPerformanceConext.
207     //
208     Boolean continueProcess(applicationContext *app, int pid);
209
210     //
211     // Disconnect the tool from the process.
212     //    app - an application context from createPerformanceConext.
213     //    pause - leave the process in a stopped state.
214     //
215     Boolean detachApplication(applicationContext *app,Boolean pause);
216
217     // 
218     // Create a performanceStream.  This a flow of performance information
219     //   to a destination. 
220     //
221     // applicationContext       - an application context.
222     // dataType                 - Sample or Trace
223     // dataCallback     - Function to call when new data arrives
224     // controlCallback  - Function to call when new structure info arrives
225     // sampleInterval   - nominal interval between samples (sample only)
226     //
227     performanceStream *createPerformanceStream(applicationContext*, 
228                                                dataType, 
229                                                dataCallback, 
230                                                controlCallback);
231         
232
233     void setSampleRate(performanceStream *stream, timeStamp sampleInterval);
234
235     //
236     // Routines to control data collection on a performanceStream.
237     //
238     // performanceStream        - a stream returned by createPerformanceStream
239     // resourceList             - a list of resources
240     // metric           - what metric to collect data for
241     //
242     metricInstance *enableDataCollection(performanceStream*,
243                                          resourceList*,
244                                          metric*);
245
246     //
247     // stop collecting data for the named metricInstance.
248     // performanceStream        - a stream returned by createPerformanceStream
249     // metricInstance   - a metricInstance returned by enableDataCollection.
250     //
251     void disableDataCollection(performanceStream*, metricInstance*);
252
253     //
254     // Return the expected cost of collecting performance data for a single
255     //    metric at a given focus.  The value returned is the fraction of
256     //    perturbation expected (i.e. 0.10 == 10% slow down expected).
257     //
258     float getPredictedDataCost(applicationContext*, resourceList*, metric*);
259
260     //
261     // Control information arriving about a resource Classes
262     //
263     // performanceStream        - a stream returned by createPerformanceStream
264     // resource         - enable notification of children of this resource
265     //
266     void enableResourceCreationNotification(performanceStream*, resource*);
267
268     //
269     // Turn off notification of creation of descendants of this resource.
270     // 
271     // performanceStream        - a stream returned by createPerformanceStream
272     // resource         - disable notification of descendants of this resource
273     //
274     //
275     void disableResourceCreationNotification(performanceStream*, resource*);
276
277     //
278     // Resource utility functions.
279     //
280     resource *getRootResource();
281
282     resourceList *getRootResources();
283
284     char *getResourceName(resource*);
285
286     resource *getResourceParent(resource*);
287
288     resource *newResource(applicationContext *app,
289                           resource *parent, 
290                           char *name);
291
292     resourceList *getResourceChildren(resource*);
293
294     Boolean isResourceDescendent(resource *parent, resource *child);
295
296     resource *findChildResource(resource *parent, char *name);
297
298     int getResourceCount(resourceList*);
299
300     resource *getNthResource(resourceList*, int n);
301
302     resourceList *createResourceList();
303
304     void addResourceList(resourceList*, resource*);
305
306     //
307     // get the canonical name of a resource list.
308     //   WARNING: The returned pointer is allocated in the heap via new
309     //      and should be freed using delete when the caller is done with it.
310     //   
311     char *getResourceListName(resourceList*);
312
313     // Get the static config. information for the passed applicationContext.
314     //
315     $array String getAvailableMetrics(applicationContext*);
316
317     //
318     // looks for a specifc metric instance in an application context.
319     //
320     metric *findMetric(applicationContext *context, char *name);
321
322     //
323     // Metric utility functions.
324     //
325     char *getMetricName(metric*);
326
327     //
328     // get the supporting info about a metric.
329     metricInfo *getMetricInfo(metric*);
330
331     //
332     // Get metric out of a metric instance.
333     //
334     metric *getMetric(metricInstance*);
335     char *getMetricNameFromMI(metricInstance*);
336
337     //
338     // Get the value of a metric.
339     //
340     sampleValue getMetricValue(metricInstance*);
341
342     //
343     // Debugger style calls.
344     //
345     void printResources();
346     void printStatus(applicationContext*);
347     void coreProcess(applicationContext*, int pid);
348
349     //
350     // upcalls for indications of events.
351     //
352     $upcall $async void newMetricDefined(metricInfoCallback, 
353                                          performanceStream*, 
354                                          metric*);
355
356     $upcall $async void newResourceDefined(resourceInfoCallback,
357                                            performanceStream *ps, 
358                                            resource *parent,
359                                            resource *newResource, 
360                                            char *name);
361
362     $upcall $async void newPerfData(sampleDataCallbackFunc, 
363                                     performanceStream *ps,
364                                     metricInstance *mi,
365                                     timeStamp startTimeStamp, 
366                                     timeStamp endTimeStamp, 
367                                     sampleValue value);
368
369     $upcall $async void histFold(histFoldCallback, 
370                                  performanceStream *ps, 
371                                  timeStamp width);
372
373       // informs that dataManager server of the name of the paradynd
374       // executable (paradynd, paradyndPVM, ...)
375     void sendParadyndName (String name);
376     $smember applicationContext *appContext;
377     $smember String paradynd_name;
378     $smember int socket;
379     $smember int sock_fd;
380 };
381
382 #endif