Remove non-emergency prints
[dyninst.git] / dyninstAPI / src / inst-sunos.C
1
2 /*
3  * inst-sunos.C - sunos specifc code for paradynd.
4  *
5  * $Log: inst-sunos.C,v $
6  * Revision 1.22  1994/11/11 10:44:03  markc
7  * Remove non-emergency prints
8  * Changed others to use statusLine
9  *
10  * Revision 1.21  1994/11/11  10:11:40  markc
11  * Used correct arg order for RPC_make_arg_list
12  *
13  * Revision 1.20  1994/11/11  07:04:55  markc
14  * Added code to bundle extra command line argument.
15  *
16  * Revision 1.19  1994/11/10  18:58:02  jcargill
17  * The "Don't Blame Me Either" commit
18  *
19  * Revision 1.18  1994/11/09  18:40:10  rbi
20  * the "Don't Blame Me" commit
21  *
22  * Revision 1.17  1994/11/02  11:06:19  markc
23  * Removed redundant code into inst.C
24  * Provide "tag" dictionary for known functions.
25  *
26  * Revision 1.16  1994/10/13  07:24:45  krisna
27  * solaris porting and updates
28  *
29  * Revision 1.15  1994/09/30  19:47:05  rbi
30  * Basic instrumentation for CMFortran
31  *
32  * Revision 1.14  1994/09/22  01:58:53  markc
33  * Enter handles for primitiveCosts into stringPool
34  * changed libraryList to List<libraryFunc*>
35  *
36  * Revision 1.13  1994/09/20  18:18:25  hollings
37  * added code to use actual clock speed for cost model numbers.
38  *
39  * Revision 1.12  1994/08/17  18:11:59  markc
40  * Changed the execv to execvp.
41  * Changed arglist in forkProcess.
42  *
43  * Revision 1.11  1994/07/22  19:16:36  hollings
44  * moved computePauseTimeMetric here, and added lib func calls for cmmd routines.
45  *
46  * Revision 1.10  1994/07/15  20:22:03  hollings
47  * fixed 64 bit record to be 32 bits.
48  *
49  * Revision 1.9  1994/07/14  23:30:26  hollings
50  * Hybrid cost model added.
51  *
52  * Revision 1.8  1994/07/12  19:46:57  jcargill
53  * Removed old code, added ability for fork paradyndCM5 when nodes start.
54  *
55  * Revision 1.7  1994/07/05  03:26:04  hollings
56  * observed cost model
57  *
58  * Revision 1.6  1994/06/29  02:52:29  hollings
59  * Added metricDefs-common.{C,h}
60  * Added module level performance data
61  * cleanedup types of inferrior addresses instrumentation defintions
62  * added firewalls for large branch displacements due to text+data over 2meg.
63  * assorted bug fixes.
64  *
65  * Revision 1.5  1994/06/27  18:56:49  hollings
66  * removed printfs.  Now use logLine so it works in the remote case.
67  * added internalMetric class.
68  * added extra paramter to metric info for aggregation.
69  *
70  * Revision 1.4  1994/03/26  20:50:47  jcargill
71  * Changed the pause/continue code.  Now it really stops, instead of
72  * spin looping.
73  *
74  * Revision 1.3  1994/03/22  21:03:14  hollings
75  * Made it possible to add new processes (& paradynd's) via addExecutable.
76  *
77  * Revision 1.2  1994/03/20  01:53:07  markc
78  * Added a buffer to each process structure to allow for multiple writers on the
79  * traceStream.  Replaced old inst-pvm.C.  Changed addProcess to return type
80  * int.
81  *
82  * Revision 1.1  1994/02/07  17:38:48  hollings
83  * Added inst-sunos to split cm-5 code from standard sunos code.
84  *
85  *
86  *
87  */
88 char inst_sunos_ident[] = "@(#) $Header: /home/jaw/CVSROOT_20081103/CVSROOT/core/dyninstAPI/src/inst-sunos.C,v 1.22 1994/11/11 10:44:03 markc Exp $";
89
90 #include "util/h/kludges.h"
91 #include "os.h"
92 #include "metric.h"
93 #include "dyninst.h"
94 #include "rtinst/h/trace.h"
95 #include "symtab.h"
96 #include "process.h"
97 #include "inst.h"
98 #include "instP.h"
99 #include "ast.h"
100 #include "ptrace_emul.h"
101 #include "dyninstRPC.SRVR.h"
102 #include "util.h"
103 #include "stats.h"
104 #include "main.h"
105 #include "perfStream.h"
106 #include "kludges.h"
107 #include "context.h"
108
109 char *getProcessStatus(process *proc)
110 {
111    char ret[80];
112
113    switch (proc->status) {
114         case running:
115             sprintf(ret, "%d running", proc->pid);
116             break;
117         case neonatal:
118             sprintf(ret, "%d neonatal", proc->pid);
119             break;
120         case stopped:
121             sprintf(ret, "%d stopped", proc->pid);
122             break;
123         case exited:
124             sprintf(ret, "%d exited", proc->pid);
125             break;
126         default:
127             sprintf(ret, "%d UNKNOWN State", proc->pid);
128             break;
129     }
130     return(ret);
131 }
132
133 //
134 // All costs are based on Measurements on a SPARC station 10/40.
135 //
136 void initPrimitiveCost()
137 {
138     /* Need to add code here to collect values for other machines */
139
140     // these happen async of the rest of the system.
141     primitiveCosts["DYNINSTalarmExpire"] = 1;
142     primitiveCosts["DYNINSTsampleValues"] = 1;
143     primitiveCosts["DYNINSTreportTimer"] = 1;
144     primitiveCosts["DYNINSTreportCounter"] = 1;
145     primitiveCosts["DYNINSTreportCost"] = 1;
146     primitiveCosts["DYNINSTreportNewTags"] = 1;
147     primitiveCosts["DYNINSTprintCost"] = 1;
148
149     // this doesn't really take any time
150     primitiveCosts["DYNINSTbreakPoint"] = 1;
151
152     // this happens before we start keeping time.
153     primitiveCosts["DYNINSTinit"] = 1;
154
155     // isthmus acutal numbers from 7/3/94 -- jkh
156     // 240 ns
157     primitiveCosts["DYNINSTincrementCounter"] = 16;
158     // 240 ns
159     primitiveCosts["DYNINSTdecrementCounter"] = 16;
160     // 7.4 usec * 70 mhz (SS-5)
161     primitiveCosts["DYNINSTstartWallTimer"] = 518;
162     // 9.6 usec * 70 mhz (SS-5)
163     primitiveCosts["DYNINSTstopWallTimer"] = 841;
164     // 1.80 usec * 70 Mhz (measured on a SS-5)
165     primitiveCosts["DYNINSTstartProcessTimer"] = 126;
166     // 3.46 usec * 70 mhz (measured on a SS-5)
167     primitiveCosts["DYNINSTstopProcessTimer"] = 242;
168
169 }
170
171 int flushPtrace()
172 {
173     return(0);
174 }
175
176 void forkNodeProcesses(process *curr, traceHeader *hr, traceFork *fr)
177 {
178     int childPid;
179     process *parent;
180     char **arg_list;
181     char command[256];
182     char application[256];
183     char app_pid[20];
184     char num_nodes[20]; 
185     char *argv[20];
186
187     if (!processMap.defines(fr->ppid)) {
188       sprintf(errorLine, "In forkNodeProcesses, parent id %d unknown", fr->ppid);
189       statusLine(errorLine);
190       return;
191     }
192     parent = processMap[fr->ppid];
193     assert(parent);
194
195     /* Build arglist */
196     arg_list = RPC_make_arg_list (pd_family, pd_type, 
197                                   pd_known_socket, pd_flag, 0, pd_machine);
198
199     sprintf (command, "%sCM5", programName);
200     sprintf (application, "%s", (curr->symbols->file).string_of());
201     sprintf (app_pid, "%d", curr->pid);
202     sprintf (num_nodes, "%d", fr->npids);
203
204     /*
205      * It would be nice if this weren't sensitive to the size of
206      * arg_list.  For the moment, only arg_list[0] --> arg_list[5]
207      * are written by RPC_make_arg_list (arg_list[6] is NULL).
208      * This is a small-time hack.
209      */
210
211     argv[0] = command;
212     argv[1] = application;
213     argv[2] = app_pid;
214     argv[3] = num_nodes;
215     argv[4] = arg_list[0];
216     argv[5] = arg_list[1];
217     argv[6] = arg_list[2];
218     argv[7] = arg_list[3];
219     argv[8] = arg_list[4];
220     argv[9] = arg_list[5];
221     argv[10] = 0;
222
223     if ((childPid=fork()) == 0) {               /* child */
224
225 /*      ptrace (0, 0, 0, 0, 0); */
226
227         execvp (command, argv);
228         logLine("Exec failed in paradynd to start paradyndCM5\n");
229         abort();
230     }
231     else {                      /* parent */
232         sprintf (errorLine, "forked child process (pid=%d)", childPid);
233         statusLine(errorLine);
234     }
235
236     /* Mark the cm-process as running now */
237 //    curr->status = running;
238
239     pauseAllProcesses();
240 }
241
242
243 /*
244  * Define the various classes of library functions to inst. 
245  *
246  */
247 void initLibraryFunctions()
248 {
249     /* should record waiting time in read/write, but have a conflict with
250      *   use of these functions by our inst code.
251      *   This happens when a CPUtimer that is stopped is stopped again by the
252      *   write.  It is then started again at the end of the write and should
253      *   not be running then.  We could let timers go negative, but this
254      *   causes a problem when inst is inserted into already running code.
255      *   Not sure what the best fix is - jkh 10/4/93
256      *
257      */
258     tagDict["write"] = TAG_LIB_FUNC | TAG_IO_OUT;
259     tagDict["read"] = TAG_LIB_FUNC | TAG_IO_IN;
260
261     tagDict["DYNINSTalarmExpire"] = TAG_LIB_FUNC;
262     tagDict["DYNINSTsampleValues"] = TAG_LIB_FUNC;
263     tagDict[EXIT_NAME] = TAG_LIB_FUNC;
264     tagDict["fork"] = TAG_LIB_FUNC;
265
266     tagDict["cmmd_debug"] = TAG_LIB_FUNC;
267     tagDict["CMRT_init"] = TAG_LIB_FUNC;
268     tagDict["CMMD_send"] = TAG_LIB_FUNC;
269     tagDict["CMMD_receive"] = TAG_LIB_FUNC;
270     tagDict["CMMD_receive_block"] = TAG_LIB_FUNC;
271     tagDict["CMMD_send_block"] = TAG_LIB_FUNC;
272     tagDict["CMMD_send_async"] = TAG_LIB_FUNC;
273     tagDict["CMMD_send_async"] = TAG_LIB_FUNC;
274
275     tagDict["main"] = 0;
276 }
277  
278 float computePauseTimeMetric()
279 {
280     timeStamp now;
281     timeStamp elapsed=0.0;
282
283     now = getCurrentTime(false);
284     if (firstRecordTime) {
285         elapsed = elapsedPauseTime;
286         if (isApplicationPaused())
287             elapsed += now - startPause;
288
289         assert(elapsed >= 0.0); 
290         return(elapsed);
291     } else {
292         return(0.0);
293     }
294 }
295
296 void osDependentInst(process *proc) {
297 }