1 char netcpu_perfstat_id[]="\ 2 @(#)netcpu_perfstat.c Version 2.4.0"; 3 4 #if HAVE_CONFIG_H 5 # include <config.h> 6 #endif 7 8 #include <stdio.h> 9 10 #if HAVE_INTTYPES_H 11 # include <inttypes.h> 12 #else 13 # if HAVE_STDINT_H 14 # include <stdint.h> 15 # endif 16 #endif 17 18 #if TIME_WITH_SYS_TIME 19 # include <sys/time.h> 20 # include <time.h> 21 #else 22 # if HAVE_SYS_TIME_H 23 # include <sys/time.h> 24 # else 25 # include <time.h> 26 # endif 27 #endif 28 29 #if HAVE_LIMITS_H 30 # include <limits.h> 31 # ifndef LONG_LONG_MAX 32 # define LONG_LONG_MAX LLONG_MAX 33 # endif /* LONG_LONG_MAX */ 34 #endif 35 36 #include <errno.h> 37 38 #include "netsh.h" 39 #include "netlib.h" 40 41 /* the lib_start_count and lib_end_count arrays hold the starting 42 and ending values of whatever is counting when the system is 43 idle. The rate at which this increments during a test is compared 44 with a previous calibration to arrive at a CPU utilization 45 percentage. raj 2005-01-26 */ 46 static uint64_t lib_start_count[MAXCPUS]; 47 static uint64_t lib_end_count[MAXCPUS]; 48 49 50 void 51 cpu_util_init(void) 52 { 53 return; 54 } 55 56 void 57 cpu_util_terminate(void) 58 { 59 return; 60 } 61 62 int 63 get_cpu_method(void) 64 { 65 return PERFSTAT; 66 } 67 68 void 69 get_cpu_idle(uint64_t *res) 70 { 71 perfstat_cpu_t *perfstat_buffer; 72 perfstat_cpu_t *per_cpu_pointer; 73 perfstat_id_t name; 74 int i,ret; 75 76 /* a name of "" will cause us to start from the beginning */ 77 strcpy(name.name,""); 78 perfstat_buffer = (perfstat_cpu_t *)malloc(lib_num_loc_cpus * 79 sizeof(perfstat_cpu_t)); 80 if (perfstat_buffer == NULL) { 81 fprintf(where, 82 "cpu_start: malloc failed errno %d\n", 83 errno); 84 fflush(where); 85 exit(-1); 86 } 87 88 /* happiness and joy, keep going */ 89 ret = perfstat_cpu(&name, 90 perfstat_buffer, 91 sizeof(perfstat_cpu_t), 92 lib_num_loc_cpus); 93 94 if ((ret == -1) || 95 (ret != lib_num_loc_cpus)) { 96 fprintf(where, 97 "cpu_start: perfstat_cpu failed/count off; errno %d cpus %d count %d\n", 98 errno, 99 lib_num_loc_cpus, 100 ret); 101 fflush(where); 102 exit(-1); 103 } 104 105 per_cpu_pointer = perfstat_buffer; 106 for (i = 0; i < lib_num_loc_cpus; i++){ 107 res[i] = per_cpu_pointer->idle; 108 per_cpu_pointer++; 109 } 110 free(perfstat_buffer); 111 112 return; 113 } 114 115 float 116 calibrate_idle_rate(int iterations, int interval) 117 { 118 unsigned long long 119 firstcnt[MAXCPUS], 120 secondcnt[MAXCPUS]; 121 122 float 123 elapsed, 124 temp_rate, 125 rate[MAXTIMES], 126 local_maxrate; 127 128 long 129 sec, 130 usec; 131 132 int 133 i, 134 j; 135 136 struct timeval time1, time2 ; 137 struct timezone tz; 138 139 perfstat_cpu_t *perfstat_buffer; 140 perfstat_cpu_t *per_cpu_pointer; 141 perfstat_id_t name; 142 int ret; 143 144 if (debug) { 145 fprintf(where,"enter calibrate_perfstat\n"); 146 fflush(where); 147 } 148 149 if (iterations > MAXTIMES) { 150 iterations = MAXTIMES; 151 } 152 153 local_maxrate = (float)-1.0; 154 155 perfstat_buffer = (perfstat_cpu_t *)malloc(lib_num_loc_cpus * 156 sizeof(perfstat_cpu_t)); 157 if (perfstat_buffer == NULL) { 158 fprintf(where, 159 "calibrate_perfstat: malloc failed errno %d\n", 160 errno); 161 fflush(where); 162 exit(-1); 163 } 164 165 for(i = 0; i < iterations; i++) { 166 rate[i] = (float)0.0; 167 /* a name of "" will cause us to start from the beginning */ 168 strcpy(name.name,""); 169 170 /* happiness and joy, keep going */ 171 ret = perfstat_cpu(&name, 172 perfstat_buffer, 173 sizeof(perfstat_cpu_t), 174 lib_num_loc_cpus); 175 176 if ((ret == -1) || 177 (ret != lib_num_loc_cpus)) { 178 fprintf(where, 179 "calibrate_perfstat: perfstat_cpu failed/count off; errno %d cpus %d count %d\n", 180 errno, 181 lib_num_loc_cpus, 182 ret); 183 fflush(where); 184 exit(-1); 185 } 186 187 per_cpu_pointer = perfstat_buffer; 188 for (j = 0; j < lib_num_loc_cpus; j++) { 189 firstcnt[j] = per_cpu_pointer->idle; 190 per_cpu_pointer++; 191 } 192 gettimeofday (&time1, &tz); 193 sleep(interval); 194 gettimeofday (&time2, &tz); 195 196 if (time2.tv_usec < time1.tv_usec) 197 { 198 time2.tv_usec += 1000000; 199 time2.tv_sec -=1; 200 } 201 sec = time2.tv_sec - time1.tv_sec; 202 usec = time2.tv_usec - time1.tv_usec; 203 elapsed = (float)sec + ((float)usec/(float)1000000.0); 204 205 /* happiness and joy, keep going */ 206 ret = perfstat_cpu(&name, 207 perfstat_buffer, 208 sizeof(perfstat_cpu_t), 209 lib_num_loc_cpus); 210 211 if ((ret == -1) || 212 (ret != lib_num_loc_cpus)) { 213 fprintf(where, 214 "calibrate_perfstat: perfstat_cpu failed/count off; errno %d cpus %d count %d\n", 215 errno, 216 lib_num_loc_cpus, 217 ret); 218 fflush(where); 219 exit(-1); 220 } 221 222 per_cpu_pointer = perfstat_buffer; 223 224 if(debug) { 225 fprintf(where, "Calibration for perfstat counter run: %d\n",i); 226 fprintf(where,"\tsec = %ld usec = %ld\n",sec,usec); 227 fprintf(where,"\telapsed time = %g\n",elapsed); 228 } 229 230 for (j = 0; j < lib_num_loc_cpus; j++) { 231 secondcnt[j] = per_cpu_pointer->idle; 232 per_cpu_pointer++; 233 if(debug) { 234 /* I know that there are situations where compilers know about */ 235 /* long long, but the library functions do not... raj 4/95 */ 236 fprintf(where, 237 "\tfirstcnt[%d] = 0x%8.8lx%8.8lx secondcnt[%d] = 0x%8.8lx%8.8lx\n", 238 j, 239 firstcnt[j], 240 firstcnt[j], 241 j, 242 secondcnt[j], 243 secondcnt[j]); 244 } 245 /* we assume that it would wrap no more than once. we also */ 246 /* assume that the result of subtracting will "fit" raj 4/95 */ 247 temp_rate = (secondcnt[j] >= firstcnt[j]) ? 248 (float)(secondcnt[j] - firstcnt[j])/elapsed : 249 (float)(secondcnt[j]-firstcnt[j]+MAXLONG)/elapsed; 250 if (temp_rate > rate[i]) rate[i] = temp_rate; 251 if(debug) { 252 fprintf(where,"\trate[%d] = %g\n",i,rate[i]); 253 fflush(where); 254 } 255 if (local_maxrate < rate[i]) local_maxrate = rate[i]; 256 } 257 } 258 if(debug) { 259 fprintf(where,"\tlocal maxrate = %g per sec. \n",local_maxrate); 260 fflush(where); 261 } 262 free(perfstat_buffer); 263 return local_maxrate; 264 } 265 266 float 267 calc_cpu_util_internal(float elapsed_time) 268 { 269 int i; 270 271 float actual_rate; 272 float correction_factor; 273 274 lib_local_cpu_util = (float)0.0; 275 /* It is possible that the library measured a time other than */ 276 /* the one that the user want for the cpu utilization */ 277 /* calculations - for example, tests that were ended by */ 278 /* watchdog timers such as the udp stream test. We let these */ 279 /* tests tell up what the elapsed time should be. */ 280 281 if (elapsed_time != 0.0) { 282 correction_factor = (float) 1.0 + 283 ((lib_elapsed - elapsed_time) / elapsed_time); 284 } 285 else { 286 correction_factor = (float) 1.0; 287 } 288 289 /* this looks just like the looper case. at least I think it */ 290 /* should :) raj 4/95 */ 291 for (i = 0; i < lib_num_loc_cpus; i++) { 292 293 /* we assume that the two are not more than a long apart. I */ 294 /* know that this is bad, but trying to go from long longs to */ 295 /* a float (perhaps a double) is boggling my mind right now. */ 296 /* raj 4/95 */ 297 298 long long 299 diff; 300 301 if (lib_end_count[i] >= lib_start_count[i]) { 302 diff = lib_end_count[i] - lib_start_count[i]; 303 } 304 else { 305 diff = lib_end_count[i] - lib_start_count[i] + LONG_LONG_MAX; 306 } 307 actual_rate = (float) diff / lib_elapsed; 308 lib_local_per_cpu_util[i] = (lib_local_maxrate - actual_rate) / 309 lib_local_maxrate * 100; 310 lib_local_cpu_util += lib_local_per_cpu_util[i]; 311 if (debug) { 312 fprintf(where, 313 "calc_cpu_util: actual_rate on cpu %d is %g max_rate %g cpu %6.2f\n", 314 i, 315 actual_rate, 316 lib_local_maxrate, 317 lib_local_per_cpu_util[i]); 318 } 319 } 320 321 /* we want the average across all n processors */ 322 lib_local_cpu_util /= (float)lib_num_loc_cpus; 323 324 if (debug) { 325 fprintf(where, 326 "calc_cpu_util: average across CPUs is %g\n",lib_local_cpu_util); 327 } 328 329 lib_local_cpu_util *= correction_factor; 330 331 if (debug) { 332 fprintf(where, 333 "calc_cpu_util: returning %g\n",lib_local_cpu_util); 334 } 335 336 return lib_local_cpu_util; 337 338 } 339 void 340 cpu_start_internal(void) 341 { 342 get_cpu_idle(lib_start_count); 343 return; 344 } 345 346 void 347 cpu_stop_internal(void) 348 { 349 get_cpu_idle(lib_end_count); 350 } 351 352
