Added callback function for paradynd's to report change in status of application.
[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.51  1995/10/19 22:39:53  mjrg
6  * Added callback function for paradynd's to report change in status of application.
7  * Added Exited status for applications.
8  * Removed breakpoints from CM5 applications.
9  * Added search for executables in a given directory.
10  *
11  * Revision 1.50  1995/10/13  22:05:53  newhall
12  * added interface routines: getResourceLabelName, getResourceName
13  * added phaseType parameter to sampleDataCallbackFunc
14  *
15  * Revision 1.49  1995/09/05  16:25:02  newhall
16  * added interface functions for PC thread
17  *
18  * Revision 1.48  1995/08/24  15:02:02  hollings
19  * AIX/SP-2 port (including option for split instruction/data heaps)
20  * Tracing of rexec (correctly spawns a paradynd if needed)
21  * Added rtinst function to read getrusage stats (can now be used in metrics)
22  * Critical Path
23  * Improved Error reporting in MDL sematic checks
24  * Fixed MDL Function call statement
25  * Fixed bugs in TK usage (strings passed where UID expected)
26  *
27  * Revision 1.47  1995/08/20  03:35:55  newhall
28  * changed parameters to DM_sequential_init, added set and clear persistent
29  * data and persistent collection flags
30  *
31  * Revision 1.46  1995/08/18  21:40:49  mjrg
32  * uncommented defineDaemon
33  *
34  * Revision 1.45  1995/08/12  22:26:47  newhall
35  * added DM_sequential_init() & DM_post_thread_create_init() members
36  * moved struct init_struct from paradyn.h to dataManager.I
37  *
38  * Revision 1.44  1995/08/11  21:50:03  newhall
39  * removed kludge()
40  *
41  * Revision 1.43  1995/08/08  03:10:35  newhall
42  * changed newPerfData and sampleDataCallbackFunc definitions
43  *
44  * Revision 1.42  1995/08/05  17:07:40  krisna
45  * `res' is used as a variable name in igen-generated code, YUCK
46  *
47  * Revision 1.41  1995/08/01 02:17:02  newhall
48  * *** empty log message ***
49  *
50  * Revision 1.40  1995/08/01  02:15:29  newhall
51  * changes to support phase interface  
52  *
53  * Revision 1.39  1995/06/02  20:57:40  newhall
54  * * removed all pointers to datamanager class objects from datamanager
55  *    interface functions and from client threads, objects are now
56  *    refered to by handles or by passing copies of DM internal data
57  * * removed applicationContext class from datamanager
58  * * replaced List and HTable container classes with STL containers
59  * * removed global variables from datamanager
60  * * remove redundant lists of class objects from datamanager
61  * * removed all stringPools and stringHandles
62  *
63  * Revision 1.37  1995/02/26  02:11:53  newhall
64  * added some phase interface routines
65  *
66  * Revision 1.36  1995/02/16  08:01:41  markc
67  * Modified interfaces:
68  *   1) XDR interfaces use strings and vectors instead of igen arrays and char*'s
69  *   2) No sync upcalls are allowed by the server in xdr interfaces
70  *   3) Redefined igen arrays that were used in thread code to use manually defined
71  *      structures rather than igen-defined, since igen did not need to know about
72  *      these structures.
73  *   4) Upped all of the version numbers since all new interface code is generated
74  *   5) Async calls are no longer handled while waiting for sync responses, these
75  *      requests are buffered.
76  *
77  * Revision 1.35  1995/01/26  17:59:30  jcargill
78  * Changed igen-generated include files to new naming convention; fixed
79  * some bugs compiling with gcc-2.6.3.
80  *
81  * Revision 1.34  1994/11/09  18:38:33  rbi
82  * the "Don't Blame Me" commit
83  *
84  * Revision 1.33  1994/11/07  14:57:44  jcargill
85  * Added ability to suppress search on children of a resource, rather than
86  * the resource itself.
87  *
88  * Revision 1.32  1994/11/04  16:28:24  rbi
89  * added getAvailableDaemons()
90  *
91  * Revision 1.31  1994/09/30  19:16:49  rbi
92  * Abstraction interface change.
93  *
94  * Revision 1.30  1994/09/22  00:43:30  markc
95  * Added "const" for char* args to addExecutable()
96  * Made String_Array declaration explicit
97  * Incremented version number
98  *
99  * Revision 1.29  1994/08/22  16:01:21  markc
100  * Remove my_pid which duplicated a class member
101  * Add daemon dictionary calls to dataManager interface.
102  *
103  * Revision 1.28  1994/08/17  17:55:26  markc
104  * Incremented version numbers because a new version of igen has been
105  * committed.
106  *
107  * Revision 1.27  1994/08/11  02:22:06  newhall
108  * increment version number
109  *
110  * Revision 1.26  1994/08/11  02:18:05  newhall
111  * added dataManager interface routine destroyPerformanceStream
112  *
113  * Revision 1.25  1994/08/08  20:14:54  hollings
114  * added suppress instrumentation command.
115  *
116  * Revision 1.24  1994/08/05  16:03:46  hollings
117  * more consistant use of stringHandle vs. char *.
118  *
119  * Revision 1.23  1994/07/25  14:56:19  hollings
120  * added suppress resource option.
121  *
122  * Revision 1.22  1994/07/14  23:44:28  hollings
123  * added getCurrentHybridCost
124  *
125  * Revision 1.21  1994/07/07  03:22:28  markc
126  * Added addDaemon function to start daemon prior to start process.
127  *
128  * Revision 1.20  1994/07/02  01:45:22  markc
129  * Removed aggregation operator from enableDataCollection call.
130  * Remove aggregation operator definitions, which are provided by
131  * util/h/aggregation.H
132  *
133  * Revision 1.19  1994/06/28  00:15:45  rbi
134  * Increment of version numbers
135  *
136  * Revision 1.18  1994/06/27  21:21:39  rbi
137  * Abstraction-specific resources and mapping information
138  *
139  * Revision 1.17  1994/06/17  22:08:11  hollings
140  * Added code to provide upcall for resource batch mode when a large number
141  * of resources is about to be added.
142  *
143  * Revision 1.16  1994/06/14  15:17:25  markc
144  * Added new argument (aggregationOperator) to enableDataCollection.  This
145  * tells the data manager how to aggregate a metric (sum, max, min, avg).
146  *
147  * Revision 1.15  1994/05/31  19:07:46  hollings
148  * Changes to make access to resources and resourceLists direct not via
149  * the dataManager thread.
150  *
151  * Revision 1.14  1994/05/18  00:49:46  hollings
152  * Bad Jeff didn't advance the version number on the last commit.
153  *
154  * Revision 1.13  1994/05/10  03:57:28  hollings
155  * Changed data upcall to return array of buckets.
156  *
157  * Revision 1.12  1994/05/09  20:53:35  hollings
158  * added changeState to dataManager, and clearSHG to performanceConsultant.
159  *
160  * Revision 1.11  1994/04/21  23:40:28  hollings
161  * Remoced setParadynd name function.
162  *
163  * Revision 1.10  1994/04/20  15:30:58  hollings
164  * added data manager function to get histogram buckets.
165  *
166  * Revision 1.9  1994/04/19  22:08:06  rbi
167  * Added GetTotValue method to get non-normalized metric data.
168  *
169  * Revision 1.8  1994/04/01  20:44:59  hollings
170  * Added calls to query bucketWidth and max number of bins.
171  *
172  * Revision 1.7  1994/03/31  01:37:21  markc
173  * added pause/continue Process.
174  *
175  * Revision 1.6  1994/03/20  01:48:51  markc
176  * Added support for paradyn daemon name.  igen function to store name.
177  *
178  * Revision 1.5  1994/03/08  17:39:23  hollings
179  * Added foldCallback and getResourceListName.
180  *
181  * Revision 1.4  1994/02/24  04:34:14  markc
182  * Added an upcall to dyninstRPC.I to allow paradynd's to report information at
183  * startup.  Added a data member to the class that igen generates.
184  *
185  * Revision 1.3  1994/02/03  23:26:50  hollings
186  * Changes to work with g++ version 2.5.2.
187  *
188  * Revision 1.2  1994/02/01  18:47:33  hollings
189  * Upgrades for performanceConsultant thread.
190  *
191  * Revision 1.1  1994/01/27  00:41:37  hollings
192  * First version of data manager interfaces.
193  *
194  */
195
196 #ifndef MMTHREAD_H
197 #define MMTHREAD_H
198
199 #include "util/h/list.h"
200 #include "util/h/sys.h"
201 #include "dyninstRPC.xdr.h"
202 #include "visi.xdr.h"
203 #include "util/h/aggregation.h"
204 #include "util/h/stringPool.h"
205 #include "paradyn/src/DMthread/DMinclude.h"
206
207 typedef enum { Trace, Sample } dataType;
208
209 /*
210  * error handler call back.
211  *
212  */
213 typedef void (*errorHandler)(int errno, char *message);
214
215 /*
216  * Handler that gets called when new sample data is delivered.
217  *
218  *   handle - a performance stream handle from createPerformanceStream
219  *   mi - a metricInstance returned by enableDataCollection
220  *   buckets - array of sampleValue filled by the DM 
221  *   first - the first bucket value
222  *   count - number of bucket values in buckets
223  *    
224  */
225 typedef void (*sampleDataCallbackFunc)(perfStreamHandle handle, 
226                                        metricInstanceHandle mi,
227                                        int bucketNum,
228                                        sampleValue value,
229                                        phaseType type);
230
231 /*
232  * Handler that gets called when new trace data is available.
233  *   
234  *   handle - a performance stream handle from createPerformanceStream
235  *   mi - a metricInstance returned by enableDataCollection
236  *   time - time of the event.
237  *   eventSize - size of the event specific data.
238  *   eventData - event specific data.
239  */
240 typedef void (*traceDataCallbackFunc)(perfStreamHandle handle, 
241                                       metricInstanceHandle mi, 
242                                       timeStamp time, 
243                                       int eventSize, 
244                                       void *eventData);
245
246 /*
247  * union to hold two types of data callback.
248  *
249  */
250 union dataCallback {
251     sampleDataCallbackFunc      sample;
252     traceDataCallbackFunc       trace;
253 };
254
255 typedef union dataCallback dataCallback;
256
257 /*
258  * Handler that gets called when a new metric is defined.
259  *
260  * handle - a performance stream handle from createPerformanceStream
261  * metricInfo - info about metric, client is resp. for deleting this struct
262  *
263  */
264 typedef void (*metricInfoCallback)(perfStreamHandle, 
265                                    const char *name,
266                                    int style,
267                                    int aggregate,
268                                    const char *units,
269                                    metricHandle handle);
270
271 /*
272  * Handler that gets called when a new resource is defined.
273  *
274  * handle - a performance stream handle from createPerformanceStream
275  * parent               - parent of new resource
276  * newResource          - new resource being created
277  * name                 - name of the new resource, client must delete
278  *
279  */
280 typedef void (*resourceInfoCallback)(perfStreamHandle handle, 
281                                      resourceHandle parent, 
282                                      resourceHandle newResource, 
283                                      const char *name,
284                                      const char *abstraction);
285
286 typedef enum batchMode { batchStart, batchEnd };
287
288 typedef void (*resourceBatchModeCallback)(perfStreamHandle, batchMode mode); 
289
290 typedef void (*histFoldCallback)(perfStreamHandle, timeStamp width, phaseType);
291
292 typedef enum appState { appRunning, appPaused, appExited };
293
294 typedef void (*appStateChangeCallback)(perfStreamHandle, appState state);
295
296 typedef void (*newPhaseCallback)(perfStreamHandle handle, 
297                                  const char *name, 
298                                  phaseHandle phase,
299                                  timeStamp begin, 
300                                  timeStamp end, 
301                                  float bucketwidth); 
302
303 struct controlCallback {
304     metricInfoCallback          mFunc;
305     resourceInfoCallback        rFunc;
306     resourceBatchModeCallback   bFunc;
307     histFoldCallback            fFunc;
308     appStateChangeCallback      sFunc;
309     newPhaseCallback            pFunc;
310 };
311
312 typedef struct controlCallback controlCallback;
313
314 $remote dataManager {
315     $base 2500;
316     $version 26;
317
318     //
319     // Start a paradyn daemon
320     //
321     bool addDaemon (const char *machine,
322                     const char *login,
323                     const char *name);
324
325     // 
326     // Define a daemon in the daemon dictionary
327     //     command = command line to exec
328     //     dir = directory to use as working directory
329     //     login = user name to execute as
330     //     name = name of dictionary entry, for matching
331     //     flavor = programming environment (metPVM, metCM5, metUNIX)
332     //     machine = machine to run this daemon on
333     //
334     //     Note - arguments that are not used should be passed in
335     //            as null, anything else will be assumed to be a
336     //            valid string.
337      bool defineDaemon (const char *command,
338                         const char *dir,
339                         const char *login,
340                         const char *name,
341                         const char *machine,
342                         const char *flavor);
343
344     //
345     // Define a program to run. 
346     //     machine = name of machine to run on
347     //     login = user to run as
348     //     name = name of daemon to run with, matches dictionary entry
349     //     dir = working directory to use
350     //
351     //     Note - arguments that are not used should be passed in
352     //            as null, anything else will be assumed to be a
353     //            valid string.
354     bool addExecutable(const char *machine, 
355                        const char *login, 
356                        const char *name, 
357                        const char *dir,
358                        const vector<string> *argv);
359
360     //
361     // Find out if an application has been defined yet.
362     //
363     bool applicationDefined();
364
365     //
366     // Start an application running (This starts the actual execution).
367     // 
368     bool startApplication();
369
370     //
371     //   Stop all processes associted with the application.
372     //
373     // Pause an application (I am not sure about this but I think we want it).
374     //      - Does this force buffered data to be delivered?
375     //  - Does a paused application respond to enable/disable commands?
376     //
377     bool pauseApplication();
378
379     //
380     // Pause a process in an application 
381     //      - Does this force buffered data to be delivered?
382     //  - Does a paused application respond to enable/disable commands?
383     //
384     bool pauseProcess(int pid);
385
386     //
387     // Continue a paused application.
388     //
389     bool continueApplication();
390
391     //
392     // Continue a paused process in an application.
393     //
394     bool continueProcess(int pid);
395
396     //
397     // Disconnect the tool from the process.
398     //    pause - leave the process in a stopped state.
399     //
400     bool detachApplication(bool pause);
401
402     // 
403     // Create a performanceStream.  This a flow of performance information
404     //   to a destination. 
405     //
406     // dataType         - Sample or Trace
407     // dataCallback     - Function to call when new data arrives
408     // controlCallback  - Function to call when new structure info arrives
409     //
410     perfStreamHandle createPerformanceStream(dataType, 
411                                              dataCallback, 
412                                              controlCallback);
413
414     // 
415     // Destroy a performance Stream.  
416     // 
417     // perfStreamHandle   - a handle returned by createPerformanceStream
418     //
419     int  destroyPerformanceStream(perfStreamHandle);
420
421     // TODO: this should go:  use a tunable const to get initial rate
422     //       and use phase mechanism as way to change rate after that 
423     //
424     void setSampleRate(perfStreamHandle handle, timeStamp sampleInterval);
425
426
427     //
428     // Routines to control data collection on a performance Stream.
429     //
430     // perfStreamHandle - a handle returned by createPerformanceStream
431     // resourceList     - a focus : DM deletes this 
432     // metric           - what metric to collect data for
433     // metricInstInfo   - info. about enabled metric/focus
434     //                    client must delete this struct
435     // phaseType        - enable collection for either the current phase
436     //                    or for global data
437     // pers_data        - if set, archive old data
438     // pers_collection  - if set, keep MI enabled on new phase definition  
439     //
440     metricInstInfo *enableDataCollection(perfStreamHandle,
441                                          const vector<resourceHandle>*,
442                                          metricHandle,
443                                          phaseType,
444                                          unsigned persistent_data,
445                                          unsigned persistent_collection);
446     //
447     // same as other enableDataCollection routine, except takes focus handle
448     // argument and returns metricInstanceHandle on successful enable 
449     //
450     metricInstanceHandle *enableDataCollection2(perfStreamHandle, 
451                                            resourceListHandle,
452                                            metricHandle, 
453                                            phaseType,
454                                            unsigned persistent_data,
455                                            unsigned persistent_collection);
456     //
457     // stop collecting data for the named metricInstance.
458     // perfStreamHandle - a handle returned by createPerformanceStream
459     // metricInstance   - a metricInstance returned by enableDataCollection.
460     // phaseType - specifies either global or current phase data
461     //
462     void disableDataCollection(perfStreamHandle, 
463                                metricInstanceHandle,
464                                phaseType);
465
466     //
467     // This routine returns a list of foci which are the result of combining
468     // each child of resource rh with the remaining resources that make up rlh
469     // if the resource rh is a component of the focus rlh, otherwise returns 0
470     //
471     vector<resourceListHandle> *magnify(resourceHandle rh, 
472                                         resourceListHandle rlh);
473
474     //
475     // returns a list of foci each of which is the result of combining a child
476     // of one of the resources with the remaining resource components of rlh,
477     // this routine returns 0 if no resource components of rlh have children
478     //
479     vector<resourceListHandle> *magnify2(resourceListHandle rlh);
480
481     //
482     // if resource rh is a decendent of a component of the focus, return a new
483     // focus consisting of rh replaced with it's corresponding entry in rlh,
484     // otherwise return the focus rlh
485     //
486     resourceListHandle *constrain(resourceHandle rh, resourceListHandle rlh);
487
488     //
489     // like constrain, except it returns 0 on failure
490     //
491     resourceListHandle *morespecific(resourceHandle rh, resourceListHandle rlh);
492
493     //
494     // returns true if seppressSearch is true for this focus
495     //
496     bool isSuppressed(resourceListHandle rlh);
497
498     //
499     // returns the name for the focus associated with this MI
500     // returns 0 on error
501     //
502     const char *getFocusNameFromMI(metricInstanceHandle mi);
503
504     //
505     // change the persistent_collection flag value for the assoc. MI
506     //
507     $async void setPersistentCollection(metricInstanceHandle);
508     $async void clearPersistentCollection(metricInstanceHandle);
509
510     //
511     // change the persistent_data flag value for the assoc. MI
512     //
513     $async void setPersistentData(metricInstanceHandle);
514     $async void clearPersistentData(metricInstanceHandle);
515
516     //
517     // Return the expected cost of collecting performance data for a single
518     //    metric at a given focus.  The value returned is the fraction of
519     //    perturbation expected (i.e. 0.10 == 10% slow down expected).
520     //
521     float getPredictedDataCost(resourceListHandle, metricHandle);
522
523     //
524     // Current best guess of the cost of inst in the system.
525     //
526     float getCurrentHybridCost();
527
528     // 
529     // Histogram/timebase information
530     //
531     timeStamp getCurrentBucketWidth();
532
533     // 
534     // Histogram/timebase information
535     //
536     timeStamp getGlobalBucketWidth();
537
538     //
539     // phase info
540     //
541     u_int getCurrentPhaseId();
542     timeStamp getCurrentStartTime();
543
544     int getMaxBins();
545
546     //
547     // Resource utility functions.
548     //
549
550     //
551     // returns handle for root resource, returns NULL on error
552     //
553     resourceHandle *getRootResource();
554
555     //
556     // returns handles of root resources, returns NULL on error
557     //
558     vector<resourceHandle> *getRootResources();
559
560     //
561     // create a new resource and return it's handle
562     //
563     resourceHandle newResource(resourceHandle parent, const char *name);
564
565     //
566     // converts from a vector of resourceHandles to a resourceListHandle
567     // 
568     resourceListHandle getResourceList(const vector<resourceHandle>*);
569
570     //
571     // converts from a resourceListHandle to a vector of resourceHandles
572     // client is responsible for deleting vector<resourceHandle>*
573     // 
574     vector<resourceHandle> *getResourceHandles(resourceListHandle);
575
576     //
577     // converts from a resource name to a resourceHandle 
578     // the resource name must be the full name ie. "/Code/blah.c/foo"
579     // returns NULL if convertion fails 
580     //
581     resourceHandle *findResource(const char *name);
582
583     //
584     // returns name of resource (this is not a unique representation of 
585     // the name instead it is the unique name trunctated)
586     // so for "/Code/blah.c/foo" this routine will return "foo"
587     //
588     string *getResourceLabelName(resourceHandle);
589
590
591     //
592     // returns full name of a resource  ie. "/Code/blah.c/foo" 
593     //
594     string *getResourceName(resourceHandle);
595
596
597     //
598     // converts from a focus name to a resourceListHandle 
599     // returns NULL if convertion fails 
600     //
601     resourceListHandle *findResourceList(const char *name);
602
603     //
604     // don't search the SHG for this node.
605     //
606     void setResourceSearchSuppress(resourceHandle res_handle, bool newValue);
607
608     //
609     // don't search the SHG for children of this node.
610     //
611     void setResourceSearchChildrenSuppress(resourceHandle res_handle, bool newValue);
612
613     //
614     // consider this resource a black box (applies to modules/procedures now).
615     //
616     void setResourceInstSuppress(resourceHandle res_handle, bool newValue);
617
618     // 
619     // returns a vector of metric names 
620     // client is responsible for deleting these
621     //
622     vector<string> *getAvailableMetrics();
623
624     //
625     // returns a vector of metric name and id pairs
626     // client is responsible for deleting these
627     //
628     vector<met_name_id> *getAvailableMetInfo();
629
630     //
631     // looks for a specifc metric instance
632     // returns NULL if search is unsuccessful
633     // 
634     metricHandle *findMetric(const char *name);
635
636     //
637     // Metric utility functions.
638     //
639     string *getMetricName(metricHandle);
640
641     //
642     // get the supporting info about a metric.
643     //
644     T_dyninstRPC::metricInfo *getMetricInfo(metricHandle);
645
646     // TODO: these shouldn't be necessary
647     // Get metric out of a metric instance.
648     //
649     metricHandle *getMetric(metricInstanceHandle);
650     string *getMetricNameFromMI(metricInstanceHandle);
651
652     //
653     // Get the value of a metric.
654     //
655     sampleValue getMetricValue(metricInstanceHandle);
656
657     //
658     // fill the passed array of buckets with the histogram sample from the
659     //   passed metricInstance.  
660     //          mi              metric instance to use
661     //          buckets         array of buckets to fill
662     //          numberOfBuckets max number of buckets to fill
663     //          first           first bin to fill (i.e. what bin goes into
664     //                          buckets[0]
665     //          phase           specifies either curr. or global phase data
666     //
667     int getSampleValues(metricInstanceHandle mi, 
668                         sampleValue *buckets,
669                         int numberOfBuckets,
670                         int first,
671                         phaseType phase);
672
673     //
674     // fill the passed array of buckets with the archived histogram values
675     // of the passed metricInstance
676     //      mi        which metric instance
677     //      phase_id  which phase
678     //
679     int getArchiveValues(metricInstanceHandle mi, 
680                         sampleValue *buckets,
681                         int numberOfBuckets,
682                         int first,
683                         phaseHandle phase_id);
684
685     //
686     // Get the total value of a metric. 
687     //  (ie. do not divide by time enabled)
688     //
689     sampleValue getTotValue(metricInstanceHandle);
690
691
692     //
693     //  start_Time: would allow a phase to be specified for some time
694     //              in the future, this would be useful for using phase
695     //              information from a config. file
696     //              a default value of -1.0 would be equivalent to now
697     //  name: would be an optional user defined identifier for the phase
698     //        each phase would still have a system defined unique id
699     //
700     $async void StartPhase(timeStamp start_Time, const char *name);
701
702
703     //
704     // returns a list of all currently defined phases in the system
705     // the caller is responsible for freeing the space associated with
706     // the list
707     //
708     vector<T_visi::phase_info> *getAllPhaseInfo();
709
710
711     //
712     // Debugger style calls.
713     //
714
715     void printResources();
716     void printStatus();
717     void coreProcess(int pid);
718
719     //
720     // probably temporary call, show defined daemons
721     //
722     void printDaemons();
723
724     //
725     // return a list of daemon names
726     //
727     vector<string> *getAvailableDaemons();
728
729     //
730     // upcalls for indications of events.
731     //
732     $upcall $async void newMetricDefined(metricInfoCallback, 
733                                          perfStreamHandle, 
734                                          const char *name,
735                                          int style,
736                                          int aggregate,
737                                          const char *units,
738                                          metricHandle handle);
739
740     $upcall $async void newResourceDefined(resourceInfoCallback,
741                                            perfStreamHandle, 
742                                            resourceHandle parent,
743                                            resourceHandle newResource, 
744                                            const char *name,
745                                            const char *abstr);
746
747     $upcall $async void changeResourceBatchMode(resourceBatchModeCallback,
748                                                 perfStreamHandle, 
749                                                 batchMode mode);
750
751     $upcall $async void newPerfData(sampleDataCallbackFunc, 
752                                     perfStreamHandle,
753                                     metricInstanceHandle mi,
754                                     int bucketNum,
755                                     sampleValue value,
756                                     phaseType type);
757
758 //    $upcall $async void newPerfData(sampleDataCallbackFunc, 
759 //                                  perfStreamHandle,
760 //                                  metricInstanceHandle mi,
761 //                                  sampleValue *buckets,
762 //                                  int total,
763 //                                  int first);
764
765     $upcall $async void histFold(histFoldCallback, 
766                                  perfStreamHandle, 
767                                  timeStamp width,
768                                  phaseType);
769
770     $upcall $async void changeState(appStateChangeCallback, 
771                                     perfStreamHandle, 
772                                     appState);
773
774     //
775     // Info. about a new phase that was created
776     //
777     $upcall $async void newPhaseInfo(newPhaseCallback, 
778                                      perfStreamHandle,
779                                      const char *,       // name
780                                      phaseHandle,       // unique id 
781                                      timeStamp,         // start time 
782                                      timeStamp,         // end time 
783                                      float);            // bucketwidth
784
785
786     // Called to inform the data manager that it is ok to parse the mdl files
787     // This informs the data manager that all igen interfaces have been created
788     // and that it is ok to use them -- the start up of all the thread is
789     // inelegant
790     // $async void kludge(char *metric_file);
791
792
793     $signore
794     static int socket;
795     static int sock_fd;
796     static int DM_sequential_init(const char*);
797     static int DM_post_thread_create_init(int);
798     static dataManager *dm;  // need this so can call setTid which is
799                              // not a static function, otherwise could
800                              // just define all DM functions as static
801     $signore
802 };
803
804 #endif