Subversion Repositories shark

Compare Revisions

Regard whitespace Rev 1516 → Rev 1517

/demos/trunk/newtrace/utils/extract.c
20,7 → 20,9
struct ctx_exec {
int ctx;
unsigned long long dtsc;
unsigned long long start;
unsigned long long dnsec;
unsigned long long tsc_start;
unsigned long long nsec_start;
};
 
struct ctx_to_pid {
31,6 → 33,7
struct endcycle {
int ctx;
unsigned long long tsc;
unsigned long long nsec;
};
 
void Error(int num, int line) {
45,10 → 48,12
struct ctx_exec *job_list;
 
unsigned int clk_per_msec = 0;
unsigned int skip_clk_per_msec = 0;
 
unsigned long long log_start_tsc = 0;
unsigned long long log_end_tsc = 0;
unsigned long long total_dtsc = 0;
unsigned long long total_tsc = 0;
unsigned long long total_nsec = 0;
 
/* Data for gnuplot external call */
int draw_data[DRAW_NUM+1];
84,7 → 89,7
gnuplot_command = popen("gnuplot -persist","w");
 
for (i=0;i<DRAW_NUM;i++)
fprintf(gnuplot_data,"%f\t%f\n",(double)i * (double)max_limit / (double)DRAW_NUM,(float)(current_mem[i]));
fprintf(gnuplot_data,"%f\t%f\n",(double)i * (double)max_limit / (double)DRAW_NUM / 1000.0,(float)(current_mem[i]));
 
fflush(gnuplot_data);
fclose(gnuplot_data);
112,133 → 117,133
}
 
int stats_from_execs(int ctx_num, unsigned long long *tot_tsc,
unsigned long long *min_tsc,
unsigned long long *mean_tsc,
unsigned long long *max_tsc,
unsigned long long *first_tsc,
int stats_from_execs(int ctx_num, unsigned long long *tot_nsec,
unsigned long long *min_nsec,
unsigned long long *mean_nsec,
unsigned long long *max_nsec,
unsigned long long *first_nsec,
int *number) {
 
unsigned long long temp_tsc;
unsigned long long temp_nsec;
int k,i;
 
temp_tsc = 0;
*max_tsc = 0;
*mean_tsc = 0;
*min_tsc = 0xFFFFFFFF;
*first_tsc = 0;
temp_nsec = 0;
*max_nsec = 0;
*mean_nsec = 0;
*min_nsec = 0xFFFFFFFF;
*first_nsec = 0;
k = 0;
for (i=0;i<exec_total;i++)
if (exec_list[i].ctx == context_list[ctx_num].ctx) {
if (*first_tsc == 0) *first_tsc = exec_list[i].start - log_start_tsc;
if (exec_list[i].dtsc > *max_tsc) *max_tsc = exec_list[i].dtsc;
if (exec_list[i].dtsc < *min_tsc) *min_tsc = exec_list[i].dtsc;
temp_tsc += exec_list[i].dtsc;
if (*first_nsec == 0) *first_nsec = exec_list[i].nsec_start;
if (exec_list[i].dnsec > *max_nsec) *max_nsec = exec_list[i].dnsec;
if (exec_list[i].dnsec < *min_nsec) *min_nsec = exec_list[i].dnsec;
temp_nsec += exec_list[i].dnsec;
k++;
}
 
*number = k;
*tot_tsc = temp_tsc;
if (k != 0) *mean_tsc = temp_tsc / k;
*tot_nsec = temp_nsec;
if (k != 0) *mean_nsec = temp_nsec / k;
 
return 0;
 
}
 
int stats_from_jobs(int ctx_num, unsigned long long *tot_tsc,
unsigned long long *min_tsc,
unsigned long long *mean_tsc,
unsigned long long *max_tsc,
unsigned long long *first_tsc,
int stats_from_jobs(int ctx_num, unsigned long long *tot_nsec,
unsigned long long *min_nsec,
unsigned long long *mean_nsec,
unsigned long long *max_nsec,
unsigned long long *first_nsec,
int *number) {
 
unsigned long long temp_tsc;
unsigned long long temp_nsec;
int k,i;
 
temp_tsc = 0;
*max_tsc = 0;
*mean_tsc = 0;
*min_tsc = 0xFFFFFFFF;
*first_tsc = 0;
temp_nsec = 0;
*max_nsec = 0;
*mean_nsec = 0;
*min_nsec = 0xFFFFFFFF;
*first_nsec = 0;
k = 0;
for (i=0;i<job_total;i++)
if (job_list[i].ctx == context_list[ctx_num].ctx) {
if (*first_tsc == 0) *first_tsc = job_list[i].start - log_start_tsc;
if (job_list[i].dtsc > *max_tsc) *max_tsc = job_list[i].dtsc;
if (job_list[i].dtsc < *min_tsc) *min_tsc = job_list[i].dtsc;
temp_tsc += job_list[i].dtsc;
if (*first_nsec == 0) *first_nsec = job_list[i].nsec_start;
if (job_list[i].dnsec > *max_nsec) *max_nsec = job_list[i].dnsec;
if (job_list[i].dnsec < *min_nsec) *min_nsec = job_list[i].dnsec;
temp_nsec += job_list[i].dnsec;
k++;
}
 
*number = k;
*tot_tsc = temp_tsc;
if (k != 0) *mean_tsc = temp_tsc / k;
*tot_nsec = temp_nsec;
if (k != 0) *mean_nsec = temp_nsec / k;
 
return 0;
 
}
 
int arr_stats_from_execs(int ctx_num, unsigned long long *min_tsc,
unsigned long long *mean_tsc,
unsigned long long *max_tsc) {
int arr_stats_from_execs(int ctx_num, unsigned long long *min_nsec,
unsigned long long *mean_nsec,
unsigned long long *max_nsec) {
 
unsigned long long last_start,temp_tsc,delta_start;
unsigned long long last_start,temp_nsec,delta_start;
int i,k;
 
last_start = 0;
temp_tsc = 0;
*max_tsc = 0;
*min_tsc = 0xFFFFFFFF;
*mean_tsc = 0;
temp_nsec = 0;
*max_nsec = 0;
*min_nsec = 0xFFFFFFFF;
*mean_nsec = 0;
k = 0;
for (i=0;i<exec_total;i++)
if (exec_list[i].ctx == context_list[ctx_num].ctx) {
if (last_start == 0) {
last_start = exec_list[i].start;
last_start = exec_list[i].nsec_start;
} else {
delta_start = exec_list[i].start - last_start;
if (delta_start > *max_tsc) *max_tsc = delta_start;
if (delta_start < *min_tsc) *min_tsc = delta_start;
temp_tsc += delta_start;
delta_start = exec_list[i].nsec_start - last_start;
if (delta_start > *max_nsec) *max_nsec = delta_start;
if (delta_start < *min_nsec) *min_nsec = delta_start;
temp_nsec += delta_start;
k++;
last_start = exec_list[i].start;
last_start = exec_list[i].nsec_start;
}
}
 
if (k != 0) *mean_tsc = temp_tsc / k;
if (k != 0) *mean_nsec = temp_nsec / k;
 
return 0;
 
}
 
int arr_stats_from_jobs(int ctx_num, unsigned long long *min_tsc,
unsigned long long *mean_tsc,
unsigned long long *max_tsc) {
int arr_stats_from_jobs(int ctx_num, unsigned long long *min_nsec,
unsigned long long *mean_nsec,
unsigned long long *max_nsec) {
 
unsigned long long last_start,temp_tsc,delta_start;
unsigned long long last_start,temp_nsec,delta_start;
int i,k;
 
last_start = 0;
temp_tsc = 0;
*max_tsc = 0;
*min_tsc = 0xFFFFFFFF;
*mean_tsc = 0;
temp_nsec = 0;
*max_nsec = 0;
*min_nsec = 0xFFFFFFFF;
*mean_nsec = 0;
k = 0;
for (i=0;i<job_total;i++)
if (job_list[i].ctx == context_list[ctx_num].ctx) {
if (last_start == 0) {
last_start = job_list[i].start;
last_start = job_list[i].nsec_start;
} else {
delta_start = job_list[i].start - last_start;
if (delta_start > *max_tsc) *max_tsc = delta_start;
if (delta_start < *min_tsc) *min_tsc = delta_start;
temp_tsc += delta_start;
delta_start = job_list[i].nsec_start - last_start;
if (delta_start > *max_nsec) *max_nsec = delta_start;
if (delta_start < *min_nsec) *min_nsec = delta_start;
temp_nsec += delta_start;
k++;
last_start = job_list[i].start;
last_start = job_list[i].nsec_start;
}
}
 
if (k != 0) *mean_tsc = temp_tsc / k;
if (k != 0) *mean_nsec = temp_nsec / k;
 
return 0;
 
252,18 → 257,18
 
gnuplot_clear();
max_limit = total_dtsc*1000/clk_per_msec;
max_limit = total_nsec;
for (i=0;i<exec_total;i++)
if (exec_list[i].ctx == context_list[ctx_num].ctx) {
int h1,h2,h3;
h1 = ((exec_list[i].start-log_start_tsc)*1000/clk_per_msec) * DRAW_NUM / max_limit;
h2 = ((exec_list[i].start+exec_list[i].dtsc-log_start_tsc)*1000/clk_per_msec) * DRAW_NUM / max_limit;
h1 = exec_list[i].nsec_start * DRAW_NUM / max_limit;
h2 = (exec_list[i].nsec_start+exec_list[i].dnsec) * DRAW_NUM / max_limit;
for (h3=h1;h3<h2;h3++)
if (h3 <= DRAW_NUM) draw_data[h3] += (exec_list[i].dtsc*1000/clk_per_msec)*(h3-h1)/(h2-h1);
if (h3 <= DRAW_NUM) draw_data[h3] += exec_list[i].dnsec/1000*(h3-h1)/(h2-h1);
for (h3=h2;h3<=DRAW_NUM;h3++)
if (h3 <= DRAW_NUM) draw_data[h3] += (exec_list[i].dtsc*1000/clk_per_msec);
if (h3 <= DRAW_NUM) draw_data[h3] += exec_list[i].dnsec/1000;
}
274,21 → 279,21
 
}
 
int plot_exec_c_distrib(int ctx_num, unsigned long long max_tsc, char *pidstr) {
int plot_exec_c_distrib(int ctx_num, unsigned long long max_nsec, char *pidstr) {
 
unsigned long long max_limit;
char tmpstr[50];
int i,h;
 
if (max_tsc == 0) return 0;
if (max_nsec == 0) return 0;
 
gnuplot_clear();
max_limit = max_tsc*1000/clk_per_msec;
max_limit = max_nsec;
 
for (i=0;i<exec_total;i++)
if (exec_list[i].ctx == context_list[ctx_num].ctx) {
h = (exec_list[i].dtsc*1000/clk_per_msec) * DRAW_NUM / max_limit;
h = exec_list[i].dnsec * DRAW_NUM / max_limit;
if (h <= DRAW_NUM) draw_data[h]++;
}
 
299,21 → 304,21
 
}
 
int plot_job_c_distrib(int ctx_num, unsigned long long max_tsc, char *pidstr) {
int plot_job_c_distrib(int ctx_num, unsigned long long max_nsec, char *pidstr) {
 
unsigned long long max_limit;
char tmpstr[50];
int i,h;
 
if (max_tsc == 0) return 0;
if (max_nsec == 0) return 0;
 
gnuplot_clear();
max_limit = max_tsc*1000/clk_per_msec;
max_limit = max_nsec;
 
for (i=0;i<job_total;i++)
if (job_list[i].ctx == context_list[ctx_num].ctx) {
h = (job_list[i].dtsc*1000/clk_per_msec) * DRAW_NUM / max_limit;
h = job_list[i].dnsec * DRAW_NUM / max_limit;
if (h <= DRAW_NUM) draw_data[h]++;
}
 
324,30 → 329,30
 
}
 
int plot_exec_arr_distrib(int ctx_num, unsigned long long max_tsc, char *pidstr) {
int plot_exec_arr_distrib(int ctx_num, unsigned long long max_nsec, char *pidstr) {
 
unsigned long long max_limit,last_start,delta_start;
char tmpstr[50];
int i,h;
 
if (max_tsc == 0) return 0;
if (max_nsec == 0) return 0;
 
gnuplot_clear();
 
max_limit = max_tsc*1000/clk_per_msec;
max_limit = max_nsec;
 
last_start = 0;
for (i=0;i<exec_total;i++)
if (exec_list[i].ctx == context_list[ctx_num].ctx) {
if (last_start == 0) {
last_start = exec_list[i].start;
last_start = exec_list[i].nsec_start;
} else {
delta_start = exec_list[i].start - last_start;
delta_start = exec_list[i].nsec_start - last_start;
 
h = (delta_start*1000/clk_per_msec) * DRAW_NUM / max_limit;
h = delta_start * DRAW_NUM / max_limit;
if (h <= DRAW_NUM) draw_data[h]++;
 
last_start = exec_list[i].start;
last_start = exec_list[i].nsec_start;
}
}
 
358,30 → 363,30
 
}
 
int plot_job_arr_distrib(int ctx_num, unsigned long long max_tsc, char *pidstr) {
int plot_job_arr_distrib(int ctx_num, unsigned long long max_nsec, char *pidstr) {
 
unsigned long long max_limit,last_start,delta_start;
char tmpstr[50];
int i,h;
 
if (max_tsc == 0) return 0;
if (max_nsec == 0) return 0;
 
gnuplot_clear();
 
max_limit = max_tsc*1000/clk_per_msec;
max_limit = max_nsec;
 
last_start = 0;
for (i=0;i<job_total;i++)
if (job_list[i].ctx == context_list[ctx_num].ctx) {
if (last_start == 0) {
last_start = job_list[i].start;
last_start = job_list[i].nsec_start;
} else {
delta_start = job_list[i].start - last_start;
delta_start = job_list[i].nsec_start - last_start;
 
h = (delta_start*1000/clk_per_msec) * DRAW_NUM / max_limit;
h = delta_start * DRAW_NUM / max_limit;
if (h <= DRAW_NUM) draw_data[h]++;
 
last_start = job_list[i].start;
last_start = job_list[i].nsec_start;
}
}
 
405,6 → 410,7
int kill_delta = 0;
 
unsigned long long last_tsc, tsc;
unsigned long long current_nsec = 0;
 
input_file = fopen(filename,"r");
 
449,7 → 455,6
 
switch (type) {
 
case 0:
case 1:
 
/* No par */
461,6 → 466,7
case 6:
case 7:
case 8:
case 10:
 
/* 1 par */
fscanf(input_file,"%d",&par1);
468,6 → 474,7
 
case 5:
case 9:
case 0:
/* 2 par */
fscanf(input_file,"%d %d",&par1,&par2);
break;
481,7 → 488,24
printf("EVT:Log starts at [%12llu]\n",tsc);
last_tsc = tsc;
log_start_tsc = tsc;
exec_list[current_exec].start = tsc;
current_nsec = 0;
 
if (par1 == 0) Error(11,k);
if (par2 == 0) Error(12,k);
 
current_context = par1;
for (i=0;i<context_total;i++)
if (par1 == context_list[i].ctx) break;
if (i == context_total) {
context_list[context_total].ctx = par1;
context_total++;
}
 
clk_per_msec = par2;
 
exec_list[current_exec].tsc_start = tsc;
exec_list[current_exec].nsec_start = current_nsec;
state = 1;
break;
 
488,10 → 512,13
case 1:
printf("EVT:Log ends at [%12llu]\n",tsc);
exec_list[current_exec].dtsc = tsc - last_tsc;
exec_list[current_exec].dnsec = exec_list[current_exec].dtsc * 1000000 / clk_per_msec;
current_nsec += exec_list[current_exec].dnsec;
exec_list[current_exec].ctx = current_context;
current_exec++;
last_tsc = tsc;
log_end_tsc = tsc;
total_nsec = current_nsec;
state = 10;
break;
499,11 → 526,14
case 2:
if (state == 0) Error(2,k);
exec_list[current_exec].dtsc = tsc - last_tsc;
exec_list[current_exec].dnsec = exec_list[current_exec].dtsc * 1000000 / clk_per_msec;
current_nsec += exec_list[current_exec].dnsec;
exec_list[current_exec].ctx = current_context;
current_exec++;
last_tsc = tsc;
current_context = INT_CTX;
exec_list[current_exec].start = tsc;
exec_list[current_exec].tsc_start = tsc - log_start_tsc;
exec_list[current_exec].nsec_start = current_nsec;
state = 2;
break;
 
511,6 → 541,8
case 3:
if (state != 2) Error(3,k);
exec_list[current_exec].dtsc = tsc - last_tsc;
exec_list[current_exec].dnsec = exec_list[current_exec].dtsc * 1000000 / clk_per_msec;
current_nsec += exec_list[current_exec].dnsec;
exec_list[current_exec].ctx = current_context;
current_exec++;
last_tsc = tsc;
525,7 → 557,8
}
}
 
exec_list[current_exec].start = tsc;
exec_list[current_exec].tsc_start = tsc;
exec_list[current_exec].nsec_start = current_nsec;
state = 1;
break;
 
533,6 → 566,8
case 4:
 
exec_list[current_exec].dtsc = tsc - last_tsc;
exec_list[current_exec].dnsec = exec_list[current_exec].dtsc * 1000000 / clk_per_msec;
current_nsec += exec_list[current_exec].dnsec;
exec_list[current_exec].ctx = current_context;
current_exec++;
last_tsc = tsc;
545,7 → 580,8
context_total++;
}
 
exec_list[current_exec].start = tsc;
exec_list[current_exec].tsc_start = tsc;
exec_list[current_exec].nsec_start = current_nsec;
state = 1;
break;
 
600,6 → 636,7
endcycle_list[current_endcycle].ctx = par1;
endcycle_list[current_endcycle].tsc = tsc;
endcycle_list[current_endcycle].nsec = current_nsec + (tsc-last_tsc) * 1000000 / clk_per_msec;
current_endcycle++;
 
break;
620,6 → 657,22
break;
 
case 10:
 
exec_list[current_exec].dtsc = tsc - last_tsc;
exec_list[current_exec].dnsec = exec_list[current_exec].dtsc * 1000000 / clk_per_msec;
current_nsec += exec_list[current_exec].dnsec;
exec_list[current_exec].ctx = current_context;
current_exec++;
last_tsc = tsc;
exec_list[current_exec].tsc_start = tsc;
exec_list[current_exec].nsec_start = current_nsec;
 
if (!skip_clk_per_msec) clk_per_msec = par1;
 
break;
 
}
 
if (current_exec == MAXJOB-1) {
647,8 → 700,8
 
int current_job = 0, h, i, k;
int temp_ctx;
unsigned long long temp_tsc, endcycle_start_tsc;
unsigned long long endcycle_end_tsc;
unsigned long long temp_nsec, endcycle_start_nsec;
unsigned long long temp_tsc, endcycle_end_nsec;
 
job_list = malloc(sizeof(struct ctx_exec) * MAXJOB);
 
655,35 → 708,38
for (k=0;k<context_total;k++) {
 
temp_ctx = context_list[k].ctx;
endcycle_start_tsc = 0;
endcycle_start_nsec = 0;
 
for (h=0;h<endcycle_total;h++) {
 
if (endcycle_list[h].ctx == temp_ctx) {
 
if (endcycle_start_tsc == 0)
endcycle_start_tsc = log_start_tsc;
if (endcycle_start_nsec == 0)
endcycle_start_nsec = 0;
 
endcycle_end_tsc = endcycle_list[h].tsc;
endcycle_end_nsec = endcycle_list[h].nsec;
temp_nsec = 0;
temp_tsc = 0;
 
job_list[current_job].start = 0;
job_list[current_job].nsec_start = 0;
 
for(i=0;i<exec_total;i++)
if (exec_list[i].ctx == temp_ctx) {
if (exec_list[i].start < endcycle_end_tsc &&
exec_list[i].start >= endcycle_start_tsc) {
if (job_list[current_job].start == 0)
job_list[current_job].start = exec_list[i].start;
if (exec_list[i].nsec_start < endcycle_end_nsec &&
exec_list[i].nsec_start >= endcycle_start_nsec) {
if (job_list[current_job].nsec_start == 0)
job_list[current_job].nsec_start = exec_list[i].nsec_start;
temp_nsec += exec_list[i].dnsec;
temp_tsc += exec_list[i].dtsc;
}
}
 
job_list[current_job].dtsc = temp_tsc;
job_list[current_job].dnsec = temp_nsec;
job_list[current_job].ctx = temp_ctx;
current_job++;
 
endcycle_start_tsc = endcycle_end_tsc;
endcycle_start_nsec = endcycle_end_nsec;
 
}
 
700,7 → 756,7
int elaborate_statistics(int num, int task_type) {
 
char pidstr[10];
unsigned long long tot_tsc,mean_tsc,max_tsc,min_tsc,first_tsc;
unsigned long long tot_nsec,mean_nsec,max_nsec,min_nsec,first_nsec;
int number;
 
switch (context_list[num].pid) {
719,90 → 775,116
 
printf("Background Task CTX [%5d] PID [%s]\n",context_list[num].ctx,pidstr);
 
stats_from_execs(num,&tot_tsc,&min_tsc,&mean_tsc,&max_tsc,&first_tsc,&number);
stats_from_execs(num,&tot_nsec,&min_nsec,&mean_nsec,&max_nsec,&first_nsec,&number);
 
printf(" Total Execution dTSC [%12llu] us [%12llu]\n",tot_tsc,tot_tsc*1000/clk_per_msec);
printf(" Mean CPU Bandwidth [%11f%c]\n",(double)(tot_tsc)/(double)(total_dtsc)*100.0,'%');
printf(" after first exec [%11f%c]\n",(double)(tot_tsc)/(double)(total_dtsc-first_tsc)*100.0,'%');
if (number > 0) {
 
printf(" Total Execution [%12llu ns]\n",tot_nsec);
printf(" Mean CPU Bandwidth [%11f%c ]\n",(double)(tot_nsec)/(double)(total_nsec)*100.0,'%');
printf(" after first exec [%11f%c ]\n",(double)(tot_nsec)/(double)(total_nsec-first_nsec)*100.0,'%');
printf(" Execs Number [%12d]\n",number);
printf(" Min Exec dTSC [%12llu] us [%12llu]\n",min_tsc, min_tsc*1000/clk_per_msec);
printf(" Mean Exec dTSC [%12llu] us [%12llu]\n",mean_tsc, mean_tsc*1000/clk_per_msec);
printf(" Max Exec dTSC [%12llu] us [%12llu]\n\n",max_tsc, max_tsc*1000/clk_per_msec);
printf(" Min Exec [%12llu ns]\n",min_nsec);
printf(" Mean Exec [%12llu ns]\n",mean_nsec);
printf(" Max Exec [%12llu ns]\n\n",max_nsec);
 
plot_exec_demand_function(num,pidstr);
 
} else {
printf(" Total Execution [%12llu ns]\n\n",tot_nsec);
}
 
}
 
if (task_type == INTERRUPT) {
 
printf("Interrupts\n");
 
stats_from_execs(num,&tot_tsc,&min_tsc,&mean_tsc,&max_tsc,&first_tsc,&number);
stats_from_execs(num,&tot_nsec,&min_nsec,&mean_nsec,&max_nsec,&first_nsec,&number);
 
printf(" Total Execution dTSC [%12llu] us [%12llu]\n",tot_tsc,tot_tsc*1000/clk_per_msec);
printf(" Mean CPU Bandwidth [%11f%c]\n",(double)(tot_tsc)/(double)(total_dtsc)*100.0,'%');
printf(" after first int [%11f%c]\n",(double)(tot_tsc)/(double)(total_dtsc-first_tsc)*100.0,'%');
if (number > 0) {
 
printf(" Total Execution [%12llu ns]\n",tot_nsec);
printf(" Mean CPU Bandwidth [%11f%c ]\n",(double)(tot_nsec)/(double)(total_nsec)*100.0,'%');
printf(" after first int [%11f%c ]\n",(double)(tot_nsec)/(double)(total_nsec-first_nsec)*100.0,'%');
printf(" Interrupts Number [%12d]\n",number);
printf(" Min Interrupt dTSC [%12llu] us [%12llu]\n",min_tsc,min_tsc*1000/clk_per_msec);
printf(" Mean Interrupt dTSC [%12llu] us [%12llu]\n",mean_tsc,mean_tsc*1000/clk_per_msec);
printf(" Max Interrupt dTSC [%12llu] us [%12llu]\n\n",max_tsc,max_tsc*1000/clk_per_msec);
printf(" Min Interrupt [%12llu ns]\n",min_nsec);
printf(" Mean Interrupt [%12llu ns]\n",mean_nsec);
printf(" Max Interrupt [%12llu ns]\n\n",max_nsec);
 
plot_exec_c_distrib(num,max_tsc,pidstr);
plot_exec_demand_function(num,pidstr);
 
arr_stats_from_execs(num,&min_tsc,&mean_tsc,&max_tsc);
plot_exec_c_distrib(num,max_nsec,pidstr);
 
if (max_tsc > 0) {
arr_stats_from_execs(num,&min_nsec,&mean_nsec,&max_nsec);
 
printf(" Min Arr. Delta dTSC [%12llu] us [%12llu]\n",min_tsc,min_tsc*1000/clk_per_msec);
printf(" Mean Arr. Delta dTSC [%12llu] us [%12llu]\n",mean_tsc,mean_tsc*1000/clk_per_msec);
printf(" Max Arr. Delta dTSC [%12llu] us [%12llu]\n\n",max_tsc,max_tsc*1000/clk_per_msec);
if (max_nsec > 0) {
 
plot_exec_arr_distrib(num,max_tsc,pidstr);
printf(" Min Arr. Delta [%12llu ns]\n",min_nsec);
printf(" Mean Arr. Delta [%12llu ns]\n",mean_nsec);
printf(" Max Arr. Delta [%12llu ns]\n\n",max_nsec);
 
plot_exec_arr_distrib(num,max_nsec,pidstr);
 
}
 
} else {
 
printf(" Total Execution [%12llu ns]\n\n",tot_nsec);
 
}
 
}
 
if (task_type == PERIODICAL) {
 
printf("Periodical Task CTX [%5d] PID [%s]\n",context_list[num].ctx,pidstr);
 
stats_from_execs(num,&tot_tsc,&min_tsc,&mean_tsc,&max_tsc,&first_tsc,&number);
stats_from_execs(num,&tot_nsec,&min_nsec,&mean_nsec,&max_nsec,&first_nsec,&number);
 
printf(" Total Execution dTSC [%12llu] us [%12llu]\n",tot_tsc,tot_tsc*1000/clk_per_msec);
printf(" Mean CPU Bandwidth [%11f%c]\n",(double)(tot_tsc)/(double)(total_dtsc)*100.0,'%');
printf(" after first exec [%11f%c]\n",(double)(tot_tsc)/(double)(total_dtsc-first_tsc)*100.0,'%');
if (number > 0) {
 
printf(" Total Execution [%12llu ns]\n",tot_nsec);
printf(" Mean CPU Bandwidth [%11f%c ]\n",(double)(tot_nsec)/(double)(total_nsec)*100.0,'%');
printf(" after first exec [%11f%c ]\n",(double)(tot_nsec)/(double)(total_nsec-first_nsec)*100.0,'%');
printf(" Execs Number [%12d]\n",number);
printf(" Min Exec dTSC [%12llu] us [%12llu]\n",min_tsc,min_tsc*1000/clk_per_msec);
printf(" Mean Exec dTSC [%12llu] us [%12llu]\n",mean_tsc,mean_tsc*1000/clk_per_msec);
printf(" Max Exec dTSC [%12llu] us [%12llu]\n\n",max_tsc,max_tsc*1000/clk_per_msec);
printf(" Min Exec [%12llu ns]\n",min_nsec);
printf(" Mean Exec [%12llu ns]\n",mean_nsec);
printf(" Max Exec [%12llu ns]\n\n",max_nsec);
 
plot_exec_demand_function(num,pidstr);
 
stats_from_jobs(num,&tot_tsc,&min_tsc,&mean_tsc,&max_tsc,&first_tsc,&number);
stats_from_jobs(num,&tot_nsec,&min_nsec,&mean_nsec,&max_nsec,&first_nsec,&number);
 
printf(" Total Job Exec dTSC [%12llu] us [%12llu]\n",tot_tsc,tot_tsc*1000/clk_per_msec);
printf(" Total Job Exec [%12llu ns]\n",tot_nsec);
printf(" Jobs Number [%12d]\n",number);
printf(" Min Job dTSC [%12llu] us [%12llu]\n",min_tsc,min_tsc*1000/clk_per_msec);
printf(" Mean Job dTSC [%12llu] us [%12llu]\n",mean_tsc,mean_tsc*1000/clk_per_msec);
printf(" Max Job dTSC [%12llu] us [%12llu]\n\n",max_tsc,max_tsc*1000/clk_per_msec);
printf(" Min Job [%12llu ns]\n",min_nsec);
printf(" Mean Job [%12llu ns]\n",mean_nsec);
printf(" Max Job [%12llu ns]\n\n",max_nsec);
 
plot_job_c_distrib(num,max_tsc,pidstr);
plot_job_c_distrib(num,max_nsec,pidstr);
 
arr_stats_from_jobs(num,&min_tsc,&mean_tsc,&max_tsc);
arr_stats_from_jobs(num,&min_nsec,&mean_nsec,&max_nsec);
 
if (max_tsc > 0) {
if (max_nsec > 0) {
 
printf(" Min Arr. Delta dTSC [%12llu] us [%12llu]\n",min_tsc,min_tsc*1000/clk_per_msec);
printf(" Mean Arr. Delta dTSC [%12llu] us [%12llu]\n",mean_tsc,mean_tsc*1000/clk_per_msec);
printf(" Max Arr. Delta dTSC [%12llu] us [%12llu]\n\n",max_tsc,max_tsc*1000/clk_per_msec);
printf(" Min Arr. Delta [%12llu ns]\n",min_nsec);
printf(" Mean Arr. Delta [%12llu ns]\n",mean_nsec);
printf(" Max Arr. Delta [%12llu ns]\n\n",max_nsec);
plot_job_arr_distrib(num,max_tsc,pidstr);
plot_job_arr_distrib(num,max_nsec,pidstr);
 
}
 
} else {
 
printf(" Total Execution [%12llu ns]\n\n",tot_nsec);
 
}
 
}
 
return 0;
 
}
811,37 → 893,32
 
int events_total,k,i;
int task_type;
unsigned long long total_tsc;
 
srand(getpid());
 
if (argc < 3) {
printf("%s: Enter the input file name and clk_per_msec [%s filename clk_per_msec]\n",argv[0],argv[0]);
if (argc < 2) {
printf("%s: Enter the input file name \"%s filename.pwc [clk_per_msec]\"\n",argv[0],argv[0]);
exit(1);
}
 
printf("\n");
 
if (argc == 3) {
skip_clk_per_msec = 1;
clk_per_msec = atoi(argv[2]);
}
printf("Clk/msec = %u\n\n",clk_per_msec);
events_total = create_lists(argv[1]);
 
total_dtsc = log_end_tsc - log_start_tsc;
total_tsc = log_end_tsc - log_start_tsc;
 
printf("\nTotal dTSC [%12llu] us [%12llu]\n", total_dtsc, total_dtsc*1000/clk_per_msec);
printf("\nTotal dTSC [%12llu] ns [%12llu]\n", total_tsc, total_nsec);
printf("Events [%12d]\n",events_total);
printf("Execs [%12d]\n",exec_total);
printf("EndCycles [%12d]\n",endcycle_total);
 
total_tsc = 0;
for (i=0;i<exec_total;i++)
total_tsc += exec_list[i].dtsc;
/* Exec total execution check */
printf("\nExec TSC sum = %llu (%2.2f)\n",total_tsc,(float)total_tsc/((float)(log_end_tsc - log_start_tsc))*100.0);
 
printf("\nPreemption Removing.... \n");
 
/* Remove preemption from the computation time */