Changed header files to reflect igen changes. main.C does not look at the number...
[dyninst.git] / paradynd / src / main.C
1 /*
2  * Main loop for the default paradynd.
3  *
4  * $Log: main.C,v $
5  * Revision 1.3  1994/02/24 04:32:33  markc
6  * Changed header files to reflect igen changes.  main.C does not look at the number of command line arguments now.
7  *
8  * Revision 1.2  1994/02/01  18:46:52  hollings
9  * Changes for adding perfConsult thread.
10  *
11  * Revision 1.1  1994/01/27  20:31:27  hollings
12  * Iinital version of paradynd speaking dynRPC igend protocol.
13  *
14  *
15  */
16 #include <stdio.h>
17 #include <stdlib.h>
18 #include <sys/types.h>
19 #include <sys/time.h>
20 #include <assert.h>
21
22 #include "util/h/list.h"
23 #include "rtinst/h/rtinst.h"
24
25 #include "symtab.h"
26 #include "process.h"
27 #include "inst.h"
28 #include "instP.h"
29 #include "ast.h"
30 #include "util.h"
31 #include "dyninstP.h"
32 #include "metric.h"
33 #include "dyninstRPC.SRVR.h"
34
35 dynRPC *tp;
36 extern void controllerMainLoop();
37 extern void initLibraryFunctions();
38
39 main(int argc, char *argv[])
40 {
41     int i;
42     metricList stuff;
43
44     initLibraryFunctions();
45
46     // TODO, process args
47     //
48     // if (argc != 1) {
49     //    printf("remote start not supported\n");
50     //    exit(-1);
51     // }
52     tp = new dynRPC(0, NULL, NULL);
53
54     //
55     // tell client about our metrics.
56     //
57     stuff = getMetricList();
58     for (i=0; i < stuff->count; i++) {
59         tp->newMetricCallback(stuff->elements[i].info);
60     }
61
62     controllerMainLoop();
63 }
64
65 void dynRPC::addResource(String parent, String name)
66 {
67     resource pr;
68     extern resource findResource(char*);
69
70     pr = findResource(parent);
71     if (pr) (void) newResource(pr, NULL, name, 0.0);
72 }
73
74 void dynRPC::coreProcess(int pid)
75 {
76     process *proc;
77
78     proc = processList.find((void *) pid);
79     dumpCore(proc);
80 }
81
82 String dynRPC::getStatus(int pid)
83 {
84     process *proc;
85     extern char *getProcessStatus(process *proc);
86
87     proc = processList.find((void *) pid);
88     return(getProcessStatus(proc));
89 }
90
91 //
92 // NOTE: This version of getAvailableMetrics assumes that new metrics are
93 //   NOT added during execution.
94 //
95 metricInfo_Array dynRPC::getAvailableMetrics(void)
96 {
97     int i;
98     static int inited;
99     static metricInfo_Array metInfo;
100
101     if (!inited) {
102         metricList stuff;
103
104         stuff = getMetricList();
105         metInfo.count = stuff->count;
106         metInfo.data = (metricInfo*) calloc(sizeof(metricInfo), metInfo.count);
107         for (i=0; i < metInfo.count; i++) {
108             metInfo.data[i] = stuff->elements[i].info;
109         }
110         inited = 1;
111     }
112     return(metInfo);
113 }
114
115 double dynRPC::getPredictedDataCost(String_Array focusString, String metric)
116 {
117     metric m;
118     double val;
119     resourceList l;
120
121     m = findMetric(metric);
122     l = findFocus(focusString.count, focusString.data);
123     if (!l) return(0.0);
124     val = guessCost(l, m);
125
126     return(val);
127 }
128
129 void dynRPC::disableDataCollection(int mid)
130 {
131     metricInstance mi;
132     extern void printResourceList(resourceList);
133
134     printf("disable of %s for RL =", getMetricName(mi->met));
135     printResourceList(mi->resList);
136     printf("\n");
137
138     mi = allMIs.find((void *) mid);
139     mi->disable();
140     allMIs.remove(mi);
141     delete(mi);
142 }
143
144 int dynRPC::enableDataCollection(String_Array foucsString,String metric)
145 {
146     int id;
147     metric m;
148     resourceList l;
149
150     m = findMetric(metric);
151     l = findFocus(foucsString.count, foucsString.data);
152     if (!l) return(-1);
153     id = startCollecting(l, m);
154     return(id);
155 }
156
157 //
158 // not implemented yet.
159 //
160 void dynRPC::setSampleRate(double sampleInterval)
161 {
162     return;
163 }
164
165 Boolean dynRPC::detachProgram(int program,Boolean pause)
166 {
167     return(detachProcess(program, pause));
168 }
169
170 //
171 // Continue program.  We really should make this work on a single pid.
172 //
173 void dynRPC::continueProgram(int program)
174 {
175     continueApplication();
176 }
177 //
178 // We really should make this work on a single pid.
179 //
180 Boolean dynRPC::pauseProgram(int program)
181 {
182     return(pauseApplication());
183 }
184
185 Boolean dynRPC::startProgram(int program)
186 {
187     continueApplication();
188     return(False);
189 }
190
191 //
192 // This is not implemented yet.
193 //
194 Boolean dynRPC::attachProgram(int pid)
195 {
196     return(FALSE);
197 }
198
199 //
200 // start a new program for the tool.
201 //
202 int dynRPC::addExecutable(int argc,String_Array argv)
203 {
204     return(addProcess(argc, argv.data));
205 }