removed obsolete files
[dyninst.git] / rtinst / src / RThppa.c
1 /*
2  * Copyright (c) 1996 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42
43 \f
44
45
46 /************************************************************************
47  * RThppa.c: timer functions for hpux
48 ************************************************************************/
49
50
51 \f
52
53
54 /************************************************************************
55  * header files.
56 ************************************************************************/
57
58 #include <sys/param.h>
59 #include <sys/types.h>
60 #include <sys/time.h>
61 #include <sys/times.h>
62 #include <sys/resource.h>
63
64 #include "kludges.h"
65 #include "rtinst/h/rtinst.h"
66
67 #ifndef hppa1_1_hp_hpux
68 #error This file should be compiled for HP only
69 #endif
70
71 #include <sys/pstat.h>
72 #include <sys/unistd.h>
73 #define _PROTOTYPES
74
75 \f
76
77
78 /************************************************************************
79  * void DYNINSTos_init(void)
80  *
81  * null initialization for generic operating system.
82 ************************************************************************/
83
84 void
85 DYNINSTos_init(int calledByFork, int calledByAttach) {
86 }
87
88
89 \f
90
91
92 /************************************************************************
93  * time64 DYNINSTgetCPUtime(void)
94  *
95  * get the total CPU time used for "an" LWP of the monitored process.
96  * this functions needs to be rewritten if a per-thread CPU time is
97  * required.  time for a specific LWP can be obtained via the "/proc"
98  * filesystem.
99  * return value is in usec units.
100 ************************************************************************/
101
102 /* 
103  * The compilng warning could be eliminated if we use cc instead
104  * of gcc. Change it if you think that's good. --ling
105  *
106  * The cpu time I got in this way is not good. Absolutely 
107  * needs improvement 
108  */
109
110 time64
111 DYNINSTgetCPUtime(void) {
112     time64 now;
113     static time64 previous=0;
114     struct pst_status pst;
115     int target = (int)getpid();
116
117   try_again:
118     if (pstat_getproc(&pst, sizeof(pst), (size_t)0, target) != -1) {
119       now = (time64)pst.pst_cptickstotal + (time64)pst.pst_cpticks;
120       now *= (time64)10000;
121       if (now<previous) {
122         goto try_again;
123       }
124       previous=now;
125       return(now);
126     }
127     else {
128       perror("pstat_getproc");
129       abort();
130   }
131 }
132
133
134 \f
135
136
137 /************************************************************************
138  * time64 DYNINSTgetWalltime(void)
139  *
140  * get the total walltime used by the monitored process.
141  * return value is in usec units.
142 ************************************************************************/
143
144 time64
145 DYNINSTgetWalltime(void) {
146     struct timeval tv;
147     if (gettimeofday(&tv, NULL) == -1) {
148         perror("gettimeofday");
149         abort();
150     }
151     return ((time64)tv.tv_sec*(time64)1000000 + (time64)tv.tv_usec);
152 }
153
154
155
156 /************************************************************************
157  *
158  *  StartProcessTimer, StartWallTimer, StopProcessTimer,
159  *  StopWallTimer to be called from the miniTrampoline.
160  *
161 ************************************************************************/
162
163
164 extern DYNINSTstartProcessTimer(tTimer *timer);
165 extern DYNINSTstartWallTimer(tTimer* timer);
166 extern DYNINSTstopProcessTimer(tTimer* timer);
167 extern DYNINSTstopWallTimer(tTimer* timer);
168
169 void
170 DYNINSTstartProcessTimer_hpux(tTimer* timer) {
171     /* if "write" is instrumented to start timers, a timer could be started */
172     /* when samples are being written back */
173
174     DYNINSTstartProcessTimer(timer); 
175 }
176
177
178
179
180 void
181 DYNINSTstartWallTimer_hpux(tTimer* timer) {
182     /* if "write" is instrumented to start timers, a timer could be started */
183     /* when samples are being written back */
184
185     DYNINSTstartWallTimer(timer);
186 }
187
188
189 void
190 DYNINSTstopProcessTimer_hpux(tTimer* timer) {
191     /* if "write" is instrumented to start timers, a timer could be started */
192     /* when samples are being written back */
193
194     DYNINSTstopProcessTimer(timer);
195 }
196
197
198
199 void
200 DYNINSTstopWallTimer_hpux(tTimer* timer) {
201     /* if "write" is instrumented to start timers, a timer could be started */
202     /* when samples are being written back */
203
204     DYNINSTstopWallTimer(timer);
205 }
206
207 #if defined(SHM_SAMPLING) && defined(MT_THREAD)
208 extern unsigned DYNINST_hash_lookup(unsigned key);
209 extern unsigned DYNINST_initialize_done;
210 extern void DYNISNT_initialize_hash(unsigned total);
211 extern void DYNINST_initialize_free(unsigned total);
212 extern unsigned DYNINST_hash_insert(unsigned k);
213
214 int DYNINSTthreadSelf(void) {
215   return(0);
216 }
217
218 int DYNINSTthreadPos(void) {
219   if (DYNINST_initialize_done) {
220     return(DYNINST_hash_lookup(DYNINSTthreadSelf()));
221   } else {
222     DYNINST_initialize_free(MAX_NUMBER_OF_THREADS);
223     DYNINST_initialize_hash(MAX_NUMBER_OF_THREADS);
224     DYNINST_initialize_done=1;
225     return(DYNINST_hash_insert(DYNINSTthreadSelf()));
226   }
227 }
228 #endif