944 lines
31 KiB
C++
944 lines
31 KiB
C++
#include <stdlib.h>
|
||
#include <malloc.h>
|
||
#include <string.h>
|
||
#include <assert.h>
|
||
#include <stdlib.h>
|
||
|
||
#include <fstream>
|
||
#include <float.h>
|
||
#include <vector>
|
||
|
||
#include "Interval.h"
|
||
#include "Vm.h"
|
||
#include "Ver.h"
|
||
|
||
#ifdef __GNUC__
|
||
#define _strdup strdup
|
||
#include "ParseString.h"
|
||
#endif
|
||
|
||
using namespace std;
|
||
|
||
extern ofstream prot;
|
||
|
||
extern int rootProcCount; // number of processors in root VM
|
||
extern double * procElapsedTime; // processor's elapsed times vector
|
||
extern VM * currentVM; // pointer to current VM
|
||
extern char * interval[]; // interval's template
|
||
|
||
Interval * CurrInterval = NULL; // pointer to current interval
|
||
int Interval::Intervallevel = 0; // current interval's level
|
||
int Interval::IntervalID = 0; // last interval's ID
|
||
|
||
|
||
Interval::Interval(int iline, char * ifile, IntervalType itype, long iindex, Interval * par_int) :
|
||
type(itype),
|
||
index(iindex),
|
||
level(Intervallevel),
|
||
EXE_count(1),
|
||
source_line(iline),
|
||
source_file(_strdup(ifile)),
|
||
io_trafic(false),
|
||
ID(++IntervalID),
|
||
num_op_io(0),
|
||
num_op_reduct(0),
|
||
num_op_shadow(0),
|
||
num_op_remote(0),
|
||
num_op_redist(0),
|
||
Total_time(0.0),
|
||
Efficiency(0.0),
|
||
Productive_time(0.0),
|
||
Productive_CPU_time(0.0),
|
||
Productive_SYS_time(0.0),
|
||
parent_interval(par_int),
|
||
count(0),
|
||
html_title(NULL),
|
||
nested_intervals(NULL)
|
||
{
|
||
int i;
|
||
|
||
// create prosessor's vector
|
||
Procs = new Processor*[rootProcCount];
|
||
for (i = 0; i < rootProcCount; i++)
|
||
Procs[i] = new Processor();
|
||
|
||
// link with parent
|
||
if (parent_interval != NULL) {
|
||
parent_interval->count++;
|
||
parent_interval->nested_intervals =
|
||
(Interval**) realloc(parent_interval->nested_intervals,
|
||
parent_interval->count * sizeof(Interval*));
|
||
parent_interval->nested_intervals[parent_interval->count -1] = this;
|
||
}
|
||
}
|
||
|
||
Interval::Interval(int arg) :
|
||
type(__IT_MAIN),
|
||
index(NO_EXPR),
|
||
level(arg),
|
||
EXE_count(1),
|
||
source_line(0),
|
||
io_trafic(false),
|
||
ID(++IntervalID),
|
||
num_op_io(0),
|
||
num_op_reduct(0),
|
||
num_op_shadow(0),
|
||
num_op_remote(0),
|
||
num_op_redist(0),
|
||
Total_time(0.0),
|
||
Efficiency(0.0),
|
||
Productive_time(0.0),
|
||
Productive_CPU_time(0.0),
|
||
Productive_SYS_time(0.0),
|
||
parent_interval(NULL),
|
||
count(0),
|
||
html_title(NULL),
|
||
nested_intervals(NULL)
|
||
{
|
||
int i;
|
||
|
||
// source_file=(char*)malloc(sizeof(char)*strlen("no_file.fdv"));
|
||
// strcpy(source_file,"no_file.fdv");
|
||
|
||
source_file=_strdup("no_file.fdv");
|
||
|
||
// create prosessor's vector
|
||
Procs = new Processor*[rootProcCount];
|
||
for (i = 0; i < rootProcCount; i++)
|
||
Procs[i] = new Processor();
|
||
}
|
||
|
||
|
||
Interval::~Interval()
|
||
{
|
||
int i;
|
||
|
||
delete source_file;
|
||
|
||
for (i = 0; i < rootProcCount; i++)
|
||
delete Procs[i];
|
||
delete Procs;
|
||
|
||
for (i = 0; i < count; i++)
|
||
delete nested_intervals[i];
|
||
|
||
delete nested_intervals;
|
||
}
|
||
|
||
int Interval::copy_poss(Interval* from, double p1, double p2)
|
||
{ long i;
|
||
for(i=0; i<MPSProcCount(); i++)
|
||
{
|
||
Procs[i]->Lost_time = Procs[i]->Lost_time * p1 + from->Procs[i]->Lost_time * p2;
|
||
Procs[i]->Execution_time = Procs[i]->Execution_time * p1 + from->Procs[i]->Execution_time * p2;
|
||
Procs[i]->Insuff_parallelism_usr = Procs[i]->Insuff_parallelism_usr * p1 + from->Procs[i]->Insuff_parallelism_usr * p2;
|
||
Procs[i]->Insuff_parallelism_sys = Procs[i]->Insuff_parallelism_sys * p1 + from->Procs[i]->Insuff_parallelism_sys * p2;
|
||
Procs[i]->Communication = Procs[i]->Communication * p1 + from->Procs[i]->Communication * p2;
|
||
Procs[i]->Idle = Procs[i]->Idle * p1 + from->Procs[i]->Idle * p2;
|
||
Procs[i]->CPU_time = Procs[i]->CPU_time * p1 + from->Procs[i]->CPU_time * p2;
|
||
Procs[i]->CPU_time_usr = Procs[i]->CPU_time_usr * p1 + from->Procs[i]->CPU_time_usr * p2;
|
||
Procs[i]->CPU_time_sys = Procs[i]->CPU_time_sys * p1 + from->Procs[i]->CPU_time_sys * p2;
|
||
}
|
||
|
||
// Productive_time = Productive_time*p1 + from->Productive_time*p2;
|
||
// Productive_CPU_time = Productive_CPU_time*p1 + from->Productive_CPU_time*p2;
|
||
// Productive_SYS_time = Productive_SYS_time*p1 + from->Productive_SYS_time*p2;
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
int Interval::copy(Interval* from)
|
||
{ copy_poss(from,0,1);
|
||
return 0;
|
||
}
|
||
|
||
double Interval::GetProcPred(int proc_no, PredType pred)
|
||
{
|
||
switch (pred)
|
||
{
|
||
case _Lost_time: return Procs[proc_no]->Lost_time;
|
||
case _Insuff_parallelism: return Procs[proc_no]->Insuff_parallelism;
|
||
case _Insuff_parallelism_sys: return Procs[proc_no]->Insuff_parallelism_sys;
|
||
case _Idle: return Procs[proc_no]->Idle;
|
||
case _Communication: return Procs[proc_no]->Communication;
|
||
case _Synchronization: return Procs[proc_no]->Synchronization;
|
||
case _Real_synchronization: return Procs[proc_no]->Real_synchronization;
|
||
case _Variation: return Procs[proc_no]->Variation;
|
||
case _Overlap: return Procs[proc_no]->Overlap;
|
||
case _Load_imbalance: return Procs[proc_no]->Load_imbalance;
|
||
case _Execution_time: return Procs[proc_no]->Execution_time;
|
||
case _CPU_time: return Procs[proc_no]->CPU_time;
|
||
case _CPU_time_usr: return Procs[proc_no]->CPU_time_usr;
|
||
case _CPU_time_sys: return Procs[proc_no]->CPU_time_sys;
|
||
case _IO_time: return Procs[proc_no]->IO_time;
|
||
case _IO_comm: return Procs[proc_no]->IO_comm;
|
||
case _IO_real_synch: return Procs[proc_no]->IO_real_synch;
|
||
case _IO_synch: return Procs[proc_no]->IO_synch;
|
||
case _IO_vary: return Procs[proc_no]->IO_vary;
|
||
case _IO_overlap: return Procs[proc_no]->IO_overlap;
|
||
case _Wait_reduction: return Procs[proc_no]->Wait_reduction;
|
||
case _Reduction_real_synch: return Procs[proc_no]->Reduction_real_synch;
|
||
}
|
||
|
||
return 0.0;
|
||
|
||
}
|
||
|
||
|
||
double Interval::GetPred(PredType pred)
|
||
{
|
||
double res;
|
||
|
||
res=0.0;
|
||
|
||
switch (pred)
|
||
{
|
||
case _Total_time: res=Total_time; break;
|
||
case _Efficiency: res=Efficiency; break;
|
||
case _Productive_time: res=Productive_time; break;
|
||
case _Productive_CPU_time: res=Productive_CPU_time; break;
|
||
case _Productive_SYS_time: res=Productive_SYS_time; break;
|
||
case _CPU_time: res=CPU_time; break;
|
||
case _CPU_time_usr: res=CPU_time_usr; break;
|
||
case _CPU_time_sys: res=CPU_time_sys; break;
|
||
}
|
||
|
||
if (res < 0)
|
||
{
|
||
printf("PREDICTOR: fatal error - zero time\n");
|
||
exit(1);
|
||
}
|
||
return res;
|
||
}
|
||
|
||
void Interval::AddTime(TimeType InfoType, int proc_no, double TimeDelta)
|
||
{ int i ;
|
||
if (io_trafic) {
|
||
// prot << "proc_no = " << proc_no << ", TimeDelta = " << TimeDelta
|
||
// << ", Execution_time = " << Procs[proc_no]->Execution_time << endl;
|
||
if ((proc_no == 0) && (InfoType != __IO_comm)) {
|
||
InfoType = __IO_time;
|
||
} else if (InfoType != __IO_comm){
|
||
return;
|
||
}
|
||
}
|
||
// printf("ADD TIME [%d] += %f\n",proc_no,TimeDelta);;
|
||
switch (InfoType) {
|
||
case __IO_time :
|
||
Procs[proc_no]->IO_time+=TimeDelta;
|
||
Procs[proc_no]->Execution_time+=TimeDelta;
|
||
procElapsedTime[proc_no] += TimeDelta;
|
||
break;
|
||
case __CPU_time_sys :
|
||
Procs[proc_no]->CPU_time_sys+=TimeDelta;
|
||
Procs[proc_no]->CPU_time+=TimeDelta;
|
||
Procs[proc_no]->Execution_time+=TimeDelta;
|
||
procElapsedTime[proc_no] += TimeDelta;
|
||
break;
|
||
case __CPU_time_usr :
|
||
//printf("Predictor: add CPU_usr[%d] timeDelta=%.10f\n",proc_no,TimeDelta);
|
||
Procs[proc_no]->CPU_time_usr+=TimeDelta;
|
||
Procs[proc_no]->CPU_time+=TimeDelta;
|
||
Procs[proc_no]->Execution_time+=TimeDelta;
|
||
procElapsedTime[proc_no] += TimeDelta;
|
||
break;
|
||
case __Wait_reduct :
|
||
Procs[proc_no]->Wait_reduction+=TimeDelta;
|
||
Procs[proc_no]->Communication+=TimeDelta;
|
||
Procs[proc_no]->Lost_time+=TimeDelta;
|
||
Procs[proc_no]->Execution_time+=TimeDelta;
|
||
procElapsedTime[proc_no] += TimeDelta;
|
||
break;
|
||
case __Wait_shadow :
|
||
Procs[proc_no]->Wait_shadow+=TimeDelta;
|
||
Procs[proc_no]->Communication+=TimeDelta;
|
||
Procs[proc_no]->Lost_time+=TimeDelta;
|
||
Procs[proc_no]->Execution_time+=TimeDelta;
|
||
procElapsedTime[proc_no] += TimeDelta;
|
||
// for (i = 0; i < MPSProcCount(); i++) printf("proc[%d].Comm.shad=%f\n",i,Procs[currentVM->map(i)]->Wait_shadow); printf("\n");
|
||
break;
|
||
case __Remote_access :
|
||
Procs[proc_no]->Remote_access+=TimeDelta;
|
||
Procs[proc_no]->Communication+=TimeDelta;
|
||
Procs[proc_no]->Lost_time+=TimeDelta;
|
||
Procs[proc_no]->Execution_time+=TimeDelta;
|
||
procElapsedTime[proc_no] += TimeDelta;
|
||
// for (i = 0; i < MPSProcCount(); i++) printf("proc[%d].Comm.Remote=%f\n",i,Procs[currentVM->map(i)]->Remote_access);
|
||
|
||
break;
|
||
case __Redistribute :
|
||
Procs[proc_no]->Redistribution+=TimeDelta;
|
||
Procs[proc_no]->Communication+=TimeDelta;
|
||
Procs[proc_no]->Lost_time+=TimeDelta;
|
||
Procs[proc_no]->Execution_time+=TimeDelta;
|
||
procElapsedTime[proc_no] += TimeDelta;
|
||
break;
|
||
case __IO_comm :
|
||
Procs[proc_no]->IO_comm+=TimeDelta;
|
||
Procs[proc_no]->Communication+=TimeDelta;
|
||
Procs[proc_no]->Lost_time+=TimeDelta;
|
||
Procs[proc_no]->Execution_time+=TimeDelta;
|
||
procElapsedTime[proc_no] += TimeDelta;
|
||
break;
|
||
case __Insuff_parall_sys :
|
||
Procs[proc_no]->Insuff_parallelism_sys+=TimeDelta;
|
||
Procs[proc_no]->Insuff_parallelism+=TimeDelta;
|
||
Procs[proc_no]->Lost_time+=TimeDelta;
|
||
|
||
break;
|
||
case __Insuff_parall_usr :
|
||
Procs[proc_no]->Insuff_parallelism_usr+=TimeDelta;
|
||
Procs[proc_no]->Insuff_parallelism+=TimeDelta;
|
||
Procs[proc_no]->Lost_time+=TimeDelta;
|
||
break;
|
||
case __Synchronize :
|
||
// printf("synch %f %f\n",procElapsedTime[proc_no],TimeDelta);
|
||
procElapsedTime[proc_no]=(procElapsedTime[proc_no]>TimeDelta)?procElapsedTime[proc_no]:TimeDelta;
|
||
Procs[proc_no]->Execution_time=procElapsedTime[proc_no];
|
||
break;
|
||
case __Variation :
|
||
// printf("vary %f %f\n",procElapsedTime[proc_no],TimeDelta);
|
||
// procElapsedTime[proc_no]=(procElapsedTime[proc_no]>TimeDelta)?procElapsedTime[proc_no]:TimeDelta;
|
||
Procs[proc_no]->Variation+=TimeDelta;
|
||
break;
|
||
case __Remote_overlap :
|
||
Procs[proc_no]->Remote_overlap+=TimeDelta;
|
||
Procs[proc_no]->Overlap+=TimeDelta;
|
||
break;
|
||
case __Reduct_overlap :
|
||
Procs[proc_no]->Reduction_overlap+=TimeDelta;
|
||
Procs[proc_no]->Overlap+=TimeDelta;
|
||
break;
|
||
case __Shadow_overlap :
|
||
Procs[proc_no]->Shadow_overlap+=TimeDelta;
|
||
Procs[proc_no]->Overlap+=TimeDelta;
|
||
break;
|
||
default:
|
||
prot << "Interval::AddTime - unknown time type " << InfoType << endl;
|
||
exit(EXIT_FAILURE);
|
||
}
|
||
|
||
// printf("Procs[%d]->Execution_time=%f\n",proc_no,Procs[proc_no]->Execution_time);
|
||
}
|
||
|
||
void Interval::AddTimeVariation(TimeType InfoType, int proc_no, double TimeDelta)
|
||
{
|
||
Procs[proc_no]->Variation+=TimeDelta;
|
||
|
||
switch (InfoType) {
|
||
case __Remote_access:
|
||
Procs[proc_no]->Remote_vary += TimeDelta;
|
||
break;
|
||
case __Redistribute:
|
||
Procs[proc_no]->Redistribution_vary += TimeDelta;
|
||
break;
|
||
case __Wait_reduct:
|
||
Procs[proc_no]->Reduction_vary += TimeDelta;
|
||
break;
|
||
case __Wait_shadow:
|
||
Procs[proc_no]->Shadow_vary += TimeDelta;
|
||
break;
|
||
case __IO_comm:
|
||
Procs[proc_no]->IO_vary += TimeDelta;
|
||
break;
|
||
}
|
||
}
|
||
|
||
void Interval::AddTimeSynchronize(TimeType InfoType, int proc_no, double TimeDelta)
|
||
{
|
||
Procs[proc_no]->Synchronization+=TimeDelta;
|
||
//====
|
||
if(InfoType!=__Synchronize && InfoType!=__Wait_reduct)
|
||
{
|
||
// Procs[proc_no]->Real_synchronization+=TimeDelta;
|
||
}
|
||
//=***
|
||
|
||
switch (InfoType) {
|
||
case __Remote_access:
|
||
Procs[proc_no]->Remote_synch += TimeDelta;
|
||
break;
|
||
case __Redistribute:
|
||
Procs[proc_no]->Redistribution_synch += TimeDelta;
|
||
break;
|
||
case __Wait_reduct:
|
||
Procs[proc_no]->Reduction_synch += TimeDelta;
|
||
break;
|
||
case __Wait_shadow:
|
||
Procs[proc_no]->Shadow_synch += TimeDelta;
|
||
break;
|
||
case __IO_comm:
|
||
Procs[proc_no]->IO_synch += TimeDelta;
|
||
break;
|
||
|
||
}
|
||
}
|
||
|
||
void Interval::AddMPSTime(TimeType InfoType, double TimeDelta)
|
||
{
|
||
int i;
|
||
// printf("Time += %.8f\n",TimeDelta);
|
||
for (i=0; i < MPSProcCount(); i++)
|
||
AddTime(InfoType, currentVM->map(i), TimeDelta);
|
||
|
||
}
|
||
|
||
//grig
|
||
void Interval::AddMPSTime(TimeType InfoType, std::vector<double> vTimeDelta)
|
||
{
|
||
int i;
|
||
double temp;
|
||
long int_proc;
|
||
|
||
for (i=0; i < MPSProcCount(); i++)
|
||
{
|
||
|
||
int_proc=currentVM->map(i);
|
||
temp=vTimeDelta[i];
|
||
AddTime(InfoType,currentVM->map(i),vTimeDelta[i]);
|
||
}
|
||
}
|
||
//\grig
|
||
|
||
|
||
|
||
|
||
|
||
|
||
void Interval::CalcIdleAndImbalance()
|
||
{
|
||
int i;
|
||
double max_ExTime=0,
|
||
max_CPUTimeSys=0,
|
||
max_CPUTimeUsr=0,
|
||
max_CPUTime=0;
|
||
|
||
// for (i = 0; i < MPSProcCount(); i++) printf("proc[%d].Comm.shad=%f\n",i,Procs[currentVM->map(i)]->Wait_shadow);
|
||
// for (i = 0; i < MPSProcCount(); i++) printf("proc[%d].Comm.Remote=%f\n",i,Procs[currentVM->map(i)]->Remote_access);
|
||
|
||
for (i = 0; i < MPSProcCount(); i++) {
|
||
|
||
/* if(rootProcCount>1)
|
||
{
|
||
printf("currentVM->map(i)==%d Procs.addr %d %d\n",currentVM->map(i), Procs[0], Procs[1]);
|
||
if((int)Procs[1]<=0)
|
||
{
|
||
exit(0);
|
||
}
|
||
}
|
||
*/
|
||
|
||
if (Procs[currentVM->map(i)]->Execution_time > max_ExTime)
|
||
max_ExTime = Procs[currentVM->map(i)]->Execution_time;
|
||
|
||
if (Procs[currentVM->map(i)]->CPU_time_sys > max_CPUTimeSys)
|
||
max_CPUTimeSys = Procs[currentVM->map(i)]->CPU_time_sys;
|
||
|
||
if (Procs[currentVM->map(i)]->CPU_time_usr > max_CPUTimeUsr)
|
||
max_CPUTimeUsr = Procs[currentVM->map(i)]->CPU_time_usr;
|
||
//grig
|
||
if (Procs[currentVM->map(i)]->CPU_time > max_CPUTime)
|
||
max_CPUTime = Procs[currentVM->map(i)]->CPU_time;
|
||
//\grig
|
||
|
||
}
|
||
|
||
for(i = 0; i < MPSProcCount(); i++) {
|
||
Procs[currentVM->map(i)]->Idle =
|
||
max_ExTime - Procs[currentVM->map(i)]->Execution_time;
|
||
//Procs[currentVM->map(i)]->Load_imbalance =
|
||
// max_CPUTimeSys - Procs[currentVM->map(i)]->CPU_time_sys;
|
||
|
||
//grig
|
||
if(max_CPUTime!=max_CPUTimeSys+max_CPUTimeUsr)
|
||
{
|
||
|
||
}
|
||
// printf("max_sys=%f max_usr=%f sys=%f usr=%f\n",max_CPUTimeSys,max_CPUTimeUsr,Procs[currentVM->map(i)]->CPU_time_sys,Procs[currentVM->map(i)]->CPU_time_usr);
|
||
Procs[currentVM->map(i)]->Load_imbalance =
|
||
max_CPUTimeSys + max_CPUTimeUsr - Procs[currentVM->map(i)]->CPU_time_sys- Procs[currentVM->map(i)]->CPU_time_usr;
|
||
|
||
//\grig
|
||
}
|
||
}
|
||
|
||
void Interval::Enter(IntervalType int_type, int line, char* file, long index)
|
||
{
|
||
int i;
|
||
Intervallevel++;
|
||
|
||
// Searching for interval
|
||
for (i=0; i < CurrInterval->count; i++)
|
||
if ((CurrInterval->nested_intervals[i]->type == int_type) &&
|
||
(CurrInterval->nested_intervals[i]->source_line == line) &&
|
||
(strcmp(CurrInterval->nested_intervals[i]->source_file, file) == 0) &&
|
||
(CurrInterval->nested_intervals[i]->index == index) )
|
||
break;
|
||
|
||
if (i >= CurrInterval->count) {
|
||
// Interval not found - create new interval and change current interval
|
||
CurrInterval = new Interval(line, file, int_type, index, CurrInterval);
|
||
} else {
|
||
CurrInterval = CurrInterval->nested_intervals[i];
|
||
CurrInterval->EXE_count++;
|
||
}
|
||
|
||
}
|
||
|
||
void Interval::Leave()
|
||
{
|
||
CurrInterval->CalcIdleAndImbalance();
|
||
CurrInterval = CurrInterval->parent_interval;
|
||
Intervallevel--;
|
||
}
|
||
|
||
//grig
|
||
double Interval::GetEffectiveParameter()
|
||
{
|
||
return this->Execution_time;
|
||
}
|
||
//\grig
|
||
|
||
double Interval::GetExecTime()
|
||
{
|
||
return this->Execution_time;
|
||
}
|
||
|
||
|
||
|
||
void Interval::Integrate()
|
||
{
|
||
int i;
|
||
double max_ExTime=0;
|
||
|
||
double CPU_time_usr_start=CPU_time_usr;
|
||
double Insuff_parallelism_usr_start=Insuff_parallelism_usr;
|
||
|
||
|
||
|
||
// integrate this interval
|
||
for(i = 0; i < rootProcCount; i++) {
|
||
|
||
IO_time += Procs[i]->IO_time;
|
||
CPU_time += Procs[i]->CPU_time;
|
||
CPU_time_sys += Procs[i]->CPU_time_sys;
|
||
CPU_time_usr += Procs[i]->CPU_time_usr;
|
||
Lost_time += Procs[i]->Lost_time;
|
||
Communication += Procs[i]->Communication;
|
||
|
||
IO_comm += Procs[i]->IO_comm;
|
||
IO_real_synch += Procs[i]->IO_real_synch;
|
||
IO_synch += Procs[i]->IO_synch;
|
||
IO_vary += Procs[i]->IO_vary;
|
||
IO_overlap += Procs[i]->IO_overlap;
|
||
|
||
Wait_reduction += Procs[i]->Wait_reduction;
|
||
// prot << "Wait_reduction=" << Wait_reduction << endl;
|
||
Reduction_real_synch += Procs[i]->Reduction_real_synch;
|
||
Reduction_synch += Procs[i]->Reduction_synch;
|
||
Reduction_vary += Procs[i]->Reduction_vary;
|
||
Reduction_overlap += Procs[i]->Reduction_overlap;
|
||
// prot << "Reduction_overlap=" << Reduction_overlap << endl;
|
||
|
||
Wait_shadow += Procs[i]->Wait_shadow;
|
||
// prot << "Wait_shadow=" << Wait_shadow << endl;
|
||
Shadow_real_synch += Procs[i]->Shadow_real_synch;
|
||
Shadow_synch += Procs[i]->Shadow_synch;
|
||
Shadow_vary += Procs[i]->Shadow_vary;
|
||
Shadow_overlap += Procs[i]->Shadow_overlap;
|
||
// prot << "Shadow_overlap=" << Shadow_overlap << endl;
|
||
|
||
Remote_access += Procs[i]->Remote_access;
|
||
Remote_real_synch += Procs[i]->Remote_real_synch;
|
||
Remote_synch += Procs[i]->Remote_synch;
|
||
Remote_vary += Procs[i]->Remote_vary;
|
||
Remote_overlap += Procs[i]->Remote_overlap;
|
||
|
||
Redistribution += Procs[i]->Redistribution;
|
||
Redistribution_real_synch+= Procs[i]->Redistribution_real_synch;
|
||
Redistribution_synch+= Procs[i]->Redistribution_synch;
|
||
Redistribution_vary+= Procs[i]->Redistribution_vary;
|
||
Redistribution_overlap+=Procs[i]->Redistribution_overlap;
|
||
|
||
Insuff_parallelism += Procs[i]->Insuff_parallelism;
|
||
Insuff_parallelism_sys+=Procs[i]->Insuff_parallelism_sys;
|
||
Insuff_parallelism_usr+=Procs[i]->Insuff_parallelism_usr;
|
||
Synchronization += Procs[i]->Synchronization;
|
||
Variation += Procs[i]->Variation;
|
||
Real_synchronization+= Procs[i]->Real_synchronization;
|
||
// Communication_SYNCH += Procs[i]->Communication_SYNCH;
|
||
Idle += Procs[i]->Idle;
|
||
Load_imbalance += Procs[i]->Load_imbalance;
|
||
Overlap += Procs[i]->Overlap;
|
||
|
||
if (max_ExTime < Procs[i]->Execution_time)
|
||
max_ExTime = Procs[i]->Execution_time;
|
||
}
|
||
|
||
Lost_time += Idle;
|
||
|
||
Execution_time = max_ExTime;
|
||
|
||
// Integrate nested intervals
|
||
|
||
for (i = 0; i < count; i++) {
|
||
|
||
nested_intervals[i]->Integrate();
|
||
|
||
num_op_io += nested_intervals[i]->num_op_io;
|
||
num_op_reduct += nested_intervals[i]->num_op_reduct;
|
||
num_op_shadow += nested_intervals[i]->num_op_shadow;
|
||
num_op_remote += nested_intervals[i]->num_op_remote;
|
||
num_op_redist += nested_intervals[i]->num_op_redist;
|
||
|
||
Execution_time += nested_intervals[i]->Execution_time;
|
||
IO_time += nested_intervals[i]->IO_time;
|
||
CPU_time += nested_intervals[i]->CPU_time;
|
||
CPU_time_sys += nested_intervals[i]->CPU_time_sys;
|
||
CPU_time_usr += nested_intervals[i]->CPU_time_usr;
|
||
Lost_time += nested_intervals[i]->Lost_time;
|
||
Communication += nested_intervals[i]->Communication;
|
||
|
||
IO_comm += nested_intervals[i]->IO_comm;
|
||
IO_real_synch += nested_intervals[i]->IO_real_synch;
|
||
IO_synch += nested_intervals[i]->IO_synch;
|
||
IO_vary += nested_intervals[i]->IO_vary;
|
||
IO_overlap += nested_intervals[i]->IO_overlap;
|
||
|
||
Wait_reduction += nested_intervals[i]->Wait_reduction;
|
||
Reduction_synch += nested_intervals[i]->Reduction_synch;
|
||
Reduction_overlap += nested_intervals[i]->Reduction_overlap;
|
||
|
||
Wait_shadow += nested_intervals[i]->Wait_shadow;
|
||
Shadow_synch += nested_intervals[i]->Shadow_synch;
|
||
Shadow_overlap += nested_intervals[i]->Shadow_overlap;
|
||
|
||
Remote_access += nested_intervals[i]->Remote_access;
|
||
Remote_synch += nested_intervals[i]->Remote_synch;
|
||
Remote_overlap += nested_intervals[i]->Remote_overlap;
|
||
|
||
Redistribution += nested_intervals[i]->Redistribution;
|
||
Redistribution_synch += nested_intervals[i]->Redistribution_synch;
|
||
Redistribution_overlap += nested_intervals[i]->Redistribution_overlap;
|
||
|
||
Insuff_parallelism += nested_intervals[i]->Insuff_parallelism;
|
||
Insuff_parallelism_sys += nested_intervals[i]->Insuff_parallelism_sys;
|
||
Insuff_parallelism_usr += nested_intervals[i]->Insuff_parallelism_usr;
|
||
Synchronization += nested_intervals[i]->Synchronization;
|
||
Real_synchronization += nested_intervals[i]->Real_synchronization;
|
||
// Communication_SYNCH += nested_intervals[i]->Communication_SYNCH;
|
||
Idle += nested_intervals[i]->Idle;
|
||
Load_imbalance += nested_intervals[i]->Load_imbalance;
|
||
Overlap += nested_intervals[i]->Overlap;
|
||
|
||
}
|
||
|
||
Total_time = Execution_time * rootProcCount;
|
||
|
||
Productive_CPU_time = CPU_time_usr - Insuff_parallelism_usr; //Insuff_parallelism_usr - <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
|
||
if(Productive_CPU_time<0)
|
||
{
|
||
printf("PREDICTOR: fatal error in Integrate - zero time = %.8f(CPU_usr) - %.8f(Ins_par_usr)\n", CPU_time_usr, Insuff_parallelism_usr);
|
||
|
||
printf(" CPU_time_usr_start=%.8f\n",CPU_time_usr_start);
|
||
printf(" Procs[ ]->CPU_time_usr= ");
|
||
for(i = 0; i < rootProcCount; i++)
|
||
printf("%.8f ", Procs[i]->CPU_time_usr);
|
||
printf("\n");
|
||
|
||
printf(" Insuff_parallelism_usr_start=%.8f\n",Insuff_parallelism_usr_start);
|
||
printf(" Procs[ ]->Insuff_parallelism_usr= ");
|
||
for(i = 0; i < rootProcCount; i++)
|
||
printf("%.8f ", Procs[i]->Insuff_parallelism_usr);
|
||
printf("\n");
|
||
|
||
exit(1);
|
||
}
|
||
|
||
Productive_SYS_time = CPU_time_sys - Insuff_parallelism_sys;
|
||
if(Productive_SYS_time<0)
|
||
{
|
||
printf("PREDICTOR: fatal error in Integrate - zero time = %.8f(CPU_sys) - %.8f(Ins_par_sys)\n", CPU_time_sys, Insuff_parallelism_sys);
|
||
exit(1);
|
||
}
|
||
Productive_time = Productive_CPU_time + Productive_SYS_time + IO_time;
|
||
|
||
// cout << "Idle = " << Idle << endl;
|
||
// cout << "Lost_time = " << Lost_time << endl;
|
||
|
||
if ((Productive_time == 0.0) && (Total_time == 0.0))
|
||
Efficiency = 1.0;
|
||
else if (Total_time == 0.0)
|
||
Efficiency = DBL_MAX;
|
||
else
|
||
Efficiency = Productive_time / Total_time;
|
||
}
|
||
|
||
// Save interval as part of HTML file
|
||
|
||
void Interval::SaveInFile(ofstream& hfile, int up, int next, int pred)
|
||
{
|
||
bool outOn = true;
|
||
int i = 0,
|
||
j = 0,
|
||
k = 0;
|
||
char idv[64];
|
||
|
||
|
||
for (i=0; interval[i] != NULL; i++) {
|
||
if (interval[i][0] == '@') {
|
||
//====
|
||
if (strcmp(interval[i], "@title@") == 0)
|
||
{
|
||
if(html_title!=NULL) hfile << html_title <<" :: ";
|
||
hfile << VER_PRED << endl;
|
||
}
|
||
else
|
||
//=***
|
||
if (strcmp(interval[i],"@label@") == 0)
|
||
hfile << '"' << _itoa(ID, idv, 10) /*HTML_file*/ << '"' << endl;
|
||
else if (strcmp(interval[i], "@typec@") == 0) {
|
||
switch(type) {
|
||
case __IT_MAIN :
|
||
hfile << "Main" << endl;
|
||
break;
|
||
case __IT_PAR :
|
||
hfile << "Par" << endl;
|
||
break;
|
||
case __IT_SEQ :
|
||
hfile << "Seq" << endl;
|
||
break;
|
||
case __IT_USER :
|
||
hfile << "User" << endl;
|
||
break;
|
||
}
|
||
} else if (strcmp(interval[i], "@levc@") == 0) {
|
||
hfile << level << endl;
|
||
} else if (strcmp(interval[i], "@counc@") == 0) {
|
||
hfile << EXE_count << endl;
|
||
} else if (strcmp(interval[i], "@linec@") == 0) {
|
||
hfile << source_line << endl;
|
||
} else if (strcmp(interval[i], "@exprc@") == 0) {
|
||
if (index != NO_EXPR)
|
||
hfile << index << endl;
|
||
} else if (strcmp(interval[i], "@filec@") == 0) {
|
||
if (source_file != NULL)
|
||
hfile << source_file << endl;
|
||
} else if (strcmp(interval[i], "@proc@") == 0) {
|
||
vector<long>::const_iterator j;
|
||
/* if (currentVM->getMType() == 0)
|
||
hfile << "ethernet ";
|
||
else
|
||
hfile << "transp ";
|
||
*/
|
||
switch (currentVM->getMType()) {
|
||
case mach_ETHERNET :
|
||
hfile << "ethernet ";
|
||
break;
|
||
case mach_TRANSPUTER:
|
||
hfile << "transp ";
|
||
break;
|
||
case mach_MYRINET:
|
||
hfile << "myrinet ";
|
||
break;
|
||
}
|
||
for (j = rootVM->getSizeArray().begin(); j < rootVM->getSizeArray().end(); j++) {
|
||
if (j != rootVM->getSizeArray().begin())
|
||
hfile << 'x';
|
||
hfile << *j;
|
||
}
|
||
} else if (strcmp(interval[i], "@effic@") == 0) {
|
||
hfile << Efficiency << endl;
|
||
} else if (strcmp(interval[i], "@exec@") == 0) {
|
||
hfile << Execution_time << endl;
|
||
} else if (strcmp(interval[i], "@total@") == 0) {
|
||
hfile << Total_time << endl;
|
||
} else if (strcmp(interval[i], "@ptime@") == 0) {
|
||
hfile << Productive_time << endl;
|
||
} else if (strcmp(interval[i], "@ptimec@") == 0) {
|
||
hfile << Productive_CPU_time << endl;
|
||
} else if (strcmp(interval[i], "@ptimes@") == 0) {
|
||
hfile << Productive_SYS_time << endl;
|
||
} else if (strcmp(interval[i], "@ptimei@") == 0) {
|
||
hfile << IO_time << endl;
|
||
} else if (strcmp(interval[i], "@lost@") == 0) {
|
||
hfile << Lost_time << endl;
|
||
} else if (strcmp(interval[i], "@insuf@") == 0) {
|
||
hfile << Insuff_parallelism << endl;
|
||
} else if (strcmp(interval[i], "@iuser@") == 0) {
|
||
hfile << Insuff_parallelism_usr << endl;
|
||
} else if (strcmp(interval[i], "@isyst@") == 0) {
|
||
hfile << Insuff_parallelism_sys << endl;
|
||
} else if (strcmp(interval[i], "@comm@") == 0) {
|
||
hfile << Communication << endl;
|
||
} else if (strcmp(interval[i], "@csyn@") == 0) {
|
||
hfile << Real_synchronization << endl;
|
||
} else if (strcmp(interval[i], "@idle@") == 0) {
|
||
hfile << Idle << endl;
|
||
} else if (strcmp(interval[i], "@imbal@") == 0) {
|
||
hfile << Load_imbalance << endl;
|
||
} else if (strcmp(interval[i], "@synch@") == 0) {
|
||
hfile << Synchronization << endl;
|
||
} else if (strcmp(interval[i], "@vary@") == 0) {
|
||
hfile << Variation << endl;
|
||
} else if (strcmp(interval[i], "@over@") == 0) {
|
||
hfile << Overlap << endl;
|
||
} else if (strcmp(interval[i], "@nopi@") == 0) {
|
||
hfile << num_op_io << endl;
|
||
} else if (strcmp(interval[i], "@comi@") == 0) {
|
||
if (outOn) hfile << IO_comm << endl;
|
||
} else if (strcmp(interval[i], "@rsynchi@") == 0) {
|
||
if (outOn) hfile << IO_real_synch << endl;
|
||
} else if (strcmp(interval[i], "@synchi@") == 0) {
|
||
if (outOn) hfile << IO_synch << endl;
|
||
} else if (strcmp(interval[i], "@varyi@") == 0) {
|
||
if (outOn) hfile << IO_vary << endl;
|
||
} else if (strcmp(interval[i], "@overi@") == 0) {
|
||
if (outOn) hfile << IO_overlap << endl;
|
||
} else if (strcmp(interval[i], "@nopr@") == 0) {
|
||
hfile << num_op_reduct << endl;
|
||
} else if (strcmp(interval[i], "@comr@") == 0) {
|
||
if (outOn) hfile << Wait_reduction << endl;
|
||
} else if (strcmp(interval[i], "@rsynchr@") == 0) {
|
||
if (outOn) hfile << Reduction_real_synch << endl;
|
||
} else if (strcmp(interval[i], "@synchr@") == 0) {
|
||
if (outOn) hfile << Reduction_synch << endl;
|
||
} else if (strcmp(interval[i], "@varyr@") == 0) {
|
||
if (outOn) hfile << Reduction_vary << endl;
|
||
} else if (strcmp(interval[i], "@overr@") == 0) {
|
||
if (outOn) hfile << Reduction_overlap << endl;
|
||
} else if (strcmp(interval[i], "@nops@") == 0) {
|
||
hfile << num_op_shadow << endl;
|
||
} else if (strcmp(interval[i], "@coms@") == 0) {
|
||
if (outOn) hfile << Wait_shadow << endl;
|
||
} else if (strcmp(interval[i], "@rsynchs@") == 0) {
|
||
if (outOn) hfile << Shadow_real_synch << endl;
|
||
} else if (strcmp(interval[i], "@synchs@") == 0) {
|
||
if (outOn) hfile << Shadow_synch << endl;
|
||
} else if (strcmp(interval[i], "@varys@") == 0) {
|
||
if (outOn) hfile << Shadow_vary << endl;
|
||
} else if (strcmp(interval[i], "@overs@") == 0) {
|
||
if (outOn) hfile << Shadow_overlap << endl;
|
||
} else if (strcmp(interval[i], "@nopa@") == 0) {
|
||
hfile << num_op_remote << endl;
|
||
} else if (strcmp(interval[i], "@coma@") == 0) {
|
||
if (outOn) hfile << Remote_access << endl;
|
||
} else if (strcmp(interval[i], "@rsyncha@") == 0) {
|
||
if (outOn) hfile << Remote_real_synch << endl;
|
||
} else if (strcmp(interval[i], "@syncha@") == 0) {
|
||
if (outOn) hfile << Remote_synch << endl;
|
||
} else if (strcmp(interval[i], "@varya@") == 0) {
|
||
if (outOn) hfile << Remote_vary << endl;
|
||
} else if (strcmp(interval[i], "@overa@") == 0) {
|
||
if (outOn) hfile << Remote_overlap << endl;
|
||
} else if (strcmp(interval[i], "@nopd@") == 0) {
|
||
hfile << num_op_redist << endl;
|
||
} else if (strcmp(interval[i], "@comd@") == 0) {
|
||
if (outOn) hfile << Redistribution << endl;
|
||
} else if (strcmp(interval[i], "@rsynchd@") == 0) {
|
||
if (outOn) hfile << Redistribution_real_synch << endl;
|
||
} else if (strcmp(interval[i], "@synchd@") == 0) {
|
||
if (outOn) hfile << Redistribution_synch << endl;
|
||
} else if (strcmp(interval[i], "@varyd@") == 0) {
|
||
if (outOn) hfile << Redistribution_vary << endl;
|
||
} else if (strcmp(interval[i], "@overd@") == 0) {
|
||
if (outOn) hfile << Redistribution_overlap << endl;
|
||
} else if (strcmp(interval[i], "@nestbeg@") == 0) {
|
||
if (count == 0)
|
||
outOn = false;
|
||
} else if (strcmp(interval[i], "@nesteds@") == 0) {
|
||
if (outOn)
|
||
j = i;
|
||
} else if (strcmp(interval[i], "@url@") == 0) {
|
||
if (outOn) {
|
||
hfile << "\"#" << _itoa(nested_intervals[k]->ID, idv, 10)
|
||
<< '"' << endl;
|
||
}
|
||
} else if (strcmp(interval[i], "@go01@") == 0) {
|
||
if (outOn)
|
||
hfile << k+1 << endl;
|
||
} else if (strcmp(interval[i], "@type@") == 0) {
|
||
if (outOn) {
|
||
switch(nested_intervals[k]->type) {
|
||
case __IT_MAIN :
|
||
hfile << "Main" << endl;
|
||
break;
|
||
case __IT_PAR :
|
||
hfile << "Par" << endl;
|
||
break;
|
||
case __IT_SEQ :
|
||
hfile << "Seq" << endl;
|
||
break;
|
||
case __IT_USER :
|
||
hfile << "User" << endl;
|
||
break;
|
||
}
|
||
}
|
||
} else if (strcmp(interval[i], "@lev@") == 0) {
|
||
if (outOn) {
|
||
hfile << nested_intervals[k]->level << endl;
|
||
}
|
||
} else if (strcmp(interval[i], "@coun@") == 0) {
|
||
if (outOn) {
|
||
hfile << nested_intervals[k]->EXE_count << endl;
|
||
}
|
||
} else if (strcmp(interval[i], "@line@") == 0) {
|
||
if (outOn) {
|
||
hfile << nested_intervals[k]->source_line << endl;
|
||
}
|
||
} else if (strcmp(interval[i], "@expr@") == 0) {
|
||
if ((outOn) && (nested_intervals[k]->index != NO_EXPR))
|
||
hfile << nested_intervals[k]->index << endl;
|
||
} else if (strcmp(interval[i], "@file@") == 0) {
|
||
if (outOn) {
|
||
hfile << nested_intervals[k]->source_file << endl;
|
||
}
|
||
} else if (strcmp(interval[i], "@nestedf@") == 0) {
|
||
if (outOn) {
|
||
k++;
|
||
if (k < count) {
|
||
i = j;
|
||
continue;
|
||
}
|
||
}
|
||
} else if (strcmp(interval[i], "@nestend@") == 0) {
|
||
outOn = true;
|
||
} else if (strcmp(interval[i], "@up@") == 0) {
|
||
hfile << "\"#" << _itoa(up, idv, 10) << '"' << endl;
|
||
} else if (strcmp(interval[i], "@pred@") == 0) {
|
||
hfile << "\"#" << _itoa(pred, idv, 10) << '"' << endl;
|
||
} else if (strcmp(interval[i], "@next@") == 0) {
|
||
hfile << "\"#" << _itoa(next, idv, 10) << '"' << endl;
|
||
} else if (strcmp(interval[i], "@home@") == 0) {
|
||
hfile << "\"#" << _itoa(1, idv, 10) << '"' << endl;
|
||
}
|
||
} else if (outOn) {
|
||
hfile << interval[i] << endl;
|
||
// prot << interval[i] << endl;
|
||
}
|
||
}
|
||
return;
|
||
|
||
}
|
||
|
||
// Save all interval's tree as HTML file (recursive)
|
||
|
||
void Interval::SaveTree(ofstream& hfile, int up, int next, int pred)
|
||
{
|
||
int i;
|
||
|
||
SaveInFile(hfile, up, next, pred);
|
||
|
||
for(i = 0; i < count; i++)
|
||
{
|
||
int pred = (i == 0) ? ID : nested_intervals[i-1]->ID;
|
||
int next = (i == count - 1) ? ID : nested_intervals[i+1]->ID;
|
||
nested_intervals[i]->SaveTree(hfile, ID, next, pred);
|
||
}
|
||
}
|
||
|
||
|
||
|