Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
4e48d497246afee197887008e69a57c20e6e52d6
SAPFOR/dvm/tools/pppa/branches/dvm4.07/src/statread.cpp

962 lines
26 KiB
C++
Raw Normal View History

added dvm/tools/
2023-09-15 08:30:58 +03:00
#define _STATFILE_
#include "zlib.h"
#include <string.h>
#include <float.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <new>
#include "bool.h"
#include "strall.h"
#include "inter.h"
#include "treeinter.h"
#include "potensyn.h"
#include "statread.h"
using namespace std;
extern short reverse,szsh,szl,szd,szv,torightto,torightfrom;
// read intervals and synchronyzation times from file
CStatRead::CStatRead(const char * name,int iIM,int jIM,short sore)
// name - file name
{
gzFile ff=NULL;
valid=TRUE;
valid_warning=0;
BOOL valid_synchro=TRUE;
valid_synchro=TRUE;
pclfrag=NULL;
pclsyn=NULL;
pic=NULL;
pch_vmssize=NULL;
pvers=NULL;
pvms *pb_vms=NULL;
proccount=0;
ff=gzopen(name,"rb");
if (ff==NULL) {
valid=FALSE;
sprintf(texterr,"Can't open file %s \n",name);
return;
}
unsigned long lbufcompr,lbufuncompr=0,luncompr,luncomprread;
pbufcompr=NULL;pbufuncompr=NULL;
char lbufplusch[12]={0};
char nprocch[12]={0};
int s; // for gzread
long l; // for gztell
short sz[QV_CONST];
unsigned char *psz; //struc sz
gzplus =0; // sign of file gz/ gz+
if (strstr(name,".gz+") !=NULL) { //file gz+
gzplus=1;
int k;
for (k=0;;k++) { // number of compressed bytes
if (gzread(ff,&(lbufplusch[k]),1)!=1) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s \n",name);
return;
}
if (lbufplusch[k]==0) break;
}
lbufuncompr=atol(lbufplusch); // size of buffer
for (k=0;k<12;k++) lbufplusch[k]=0;
for (k=0;;k++) { // number of processors
if (gzread(ff,&(nprocch[k]),1)!=1) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s \n",name);
return;
}
if (nprocch[k]==0) break;
}
for (k=0;;k++) { // number of compressed bytes
if (gzread(ff,&(lbufplusch[k]),1)!=1) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s \n",name);
return;
}
if (lbufplusch[k]==0) break;
}
lbufcompr=atol(lbufplusch);
pbufcompr=new unsigned char[lbufcompr];
if (pbufcompr==NULL) throw("Out of memory\n");
luncompr=lbufuncompr+lbufuncompr/1000+12; // length uncompressed buffer
luncomprread=luncompr;
if (pbufcompr!=NULL) {
pbufuncompr=new unsigned char[luncompr];
if (pbufuncompr==NULL) throw("Out of memory\n");
}
s=gzread(ff,pbufcompr,lbufcompr);
if (s!=(int)lbufcompr) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s l=%ld\n",name,lbufcompr);
return;
}
int err=uncompress(pbufuncompr,&luncomprread,pbufcompr,lbufcompr);
if (err!=Z_OK || luncomprread!=lbufuncompr) {
valid=FALSE;
sprintf(texterr,"Can't uncompress l=%ld\n",lbufcompr);
return;
}
psz=pbufuncompr;
} else { // file gz or other files
l=gztell(ff);
psz=(unsigned char *)(&(sz[0]));
// read const information about size of variables and reverse
s=gzread(ff,&sz,sizeof(sz));
if (s!=(int)sizeof(sz)) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s addr=%ld size=%d\n",
name,l,(int)sizeof(sz));
return;
}
}
// data presentation
memcpy(&reverse,psz,2); // variables reverse and toright for CPYMEM
if (reverse!=1) {
short imcpy,sh1=0;
for (imcpy=sizeof(reverse)-1;imcpy>=0;imcpy--) {
*((unsigned char*)(&sh1)+imcpy)=
*((unsigned char *)(&reverse)+sizeof(reverse)-1-imcpy);
}
if (sh1!=1) {
valid=FALSE;
sprintf(texterr,"Analyzing file %s is not statistics\n",name);
return;
}
reverse=1;
}else reverse=0;
short left=1; torightto=0;torightfrom=0;
char *pleft=(char *)&left;
if (reverse==1) { // data reverse
if (pleft[0]==0 ) torightto=1;else torightfrom=1;
}
// size of used variables
CPYMEM(szsh,psz+2,2);
CPYMEM(szl,psz+4,2);
CPYMEM(szv,psz+6,2);
CPYMEM(szd,psz+8,2);
if ((szsh!=SZSH) || /*(szl>SZL) || (szv>SZV) ||*/ (szd!=SZD)) {
valid=FALSE;
sprintf(texterr,"Size of accumulating data > size of machine data %d>%d\n",
szsh,(int)SZSH);
return;
}
if ((szl>SZL) || (szv>SZV) ) {
sprintf(textwarning[valid_warning],"Number of operation may be incorrect. Data size not equal. %d>%d %d>%d\n",
szl,(int)SZL,szv,(int)SZV);
valid_warning++;
}
// calculate size of const information
int lvms=QV_SHORT*szsh+QV_LONG*szl+QV_VOID*szv+QV_DOUBLE*szd;
// read const information from file
unsigned char *pch_vms=NULL;
if (gzplus==1) pch_vms=pbufuncompr+sizeof(sz);
else {
pch_vms=new unsigned char[lvms];
if (pch_vms==NULL) throw("Out of memory\n");
l=gztell(ff);
s=gzread(ff,pch_vms,lvms);
if (s!=lvms) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s addr=%ld size=%d\n",
name,l,lvms);
return;
}
}
unsigned long linter=0; // read there only for control
CPYMEM(linter,pch_vms+MAKELONG(pb_vms,linter,proccount,QV_SHORT),szl);
if (linter<=0) {
valid=FALSE;
sprintf(texterr,"Execution was exit with statistics error. \n");
return;
}
// smallbuff - not enough memory in buffer,not all data accumulated
CPYMEM(smallbuff,pch_vms+MAKESHORT(pb_vms,smallbuff,rank),szsh);
if (smallbuff==1) {
sprintf(textwarning[valid_warning],
"Not all times of collective operations were accumulated\n");
valid_warning++;
}
CPYMEM(rank,pch_vms+MAKESHORT(pb_vms,rank,rank),szsh);
// global size of const information
size_t lvms_add=lvms+szl*rank+QV_CONST*2;
// size of VMS run
pch_vmssize=new unsigned char[szl*rank];
if (pch_vmssize==NULL) throw("Out of memory\n");
if (gzplus==1) memcpy(pch_vmssize,pbufuncompr+sizeof(sz)+lvms,szl*rank);
else {
l=gztell(ff);
s=gzread(ff,pch_vmssize,szl*rank);
if (s!=szl*rank) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s addr=%ld size=%d\n",
name,l,szl*rank);
return;
}
}
CPYMEM(maxnlevel,pch_vms+MAKESHORT(pb_vms,maxnlev,rank),szsh);
CPYMEM(proccount,pch_vms+MAKELONG(pb_vms,proccount,proccount,QV_SHORT),szl);
pclfrag=new CTreeInter*[proccount];
if (pclfrag==NULL) throw("Out of memory\n");
unsigned long i;
for (i=0;i<proccount;i++) pclfrag[i]=NULL;
// allocate memory for pointer of synchronization times
pclsyn=new CSynchro*[proccount];
if (pclsyn==NULL) throw("Out of memory\n");
// proccount - number of processors, the main loop
for (i=0;i<proccount;i++) pclsyn[i]=NULL;
unsigned long lsynchro=0;
for (i=0;i<proccount;i++) {// main processor's loop
unsigned long qfrag=0;
short maxn=0;
// qfrag - number of intervals
CPYMEM(qfrag,pch_vms+MAKELONG(pb_vms,qfrag,proccount,QV_SHORT),szl);
// maxn - number of levels
CPYMEM(maxn,pch_vms+MAKESHORT(pb_vms,maxnlev,rank),szsh);
// linter - size of all intervals in bytes
CPYMEM(linter,pch_vms+MAKELONG(pb_vms,linter,proccount,QV_SHORT),szl); //all variables on other processors may be not equivalent
char *pbuffer=NULL;
CPYMEM(pbuffer,pch_vms+MAKEVOID(pb_vms,pbuffer,pbuffer,QV_SHORT,QV_LONG),szv);
// length of version, platform and processor name
short lvers=0;
CPYMEM(lvers,pch_vms+MAKESHORT(pb_vms,lvers,rank),szsh);
// different values on each processor
if (lvers<=0) {
valid=FALSE;
sprintf(texterr,"Incorrect version\n");
return;
}
pvers=new char[lvers];
if (pvers==NULL) throw("Out of memory\n");
l=gztell(ff);
if (gzplus==1) {
memcpy(pvers,(char *)(pbufuncompr+sizeof(sz)+lvms+szl*rank),lvers);
} else {
// read from file platform, version number, processor name and time
s=gzread(ff,pvers,lvers);
if (s!=lvers) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s addr=%ld size=%d\n",
name,l,lvers);
return;
}
}
pbuffer=pbuffer+lvms_add+lvers;
unsigned char * pinterinbuff;
if (gzplus==1) pinterinbuff=pbufuncompr+lvms_add+lvers;
else pinterinbuff=NULL;
// processor name
char * pprocname=pvers+strlen(pvers)+strlen(pvers+strlen(pvers)+1)+2;
double proct=0.;// processor time
CPYMEM(proct,pch_vms+MAKEDOUBLE(pb_vms,proctime,proctime,QV_SHORT,QV_LONG,QV_VOID),szd);
// create interval tree
pclfrag[i]=new CTreeInter(ff,linter,pbuffer,i,qfrag,maxn,
pprocname,proct,iIM,jIM,sore,pinterinbuff);
if (pclfrag[i]==NULL) throw("Out of memory\n");
valid=pclfrag[i]->Valid();
if (!valid) {
pclfrag[i]->TextErr(texterr);
return;
}
unsigned long lbuf=0;
// lbuf - size of buffer
CPYMEM(lbuf,pch_vms+MAKELONG(pb_vms,lbuf,proccount,QV_SHORT),szl);
// lsynchro - size of synchronyzation times in bytes
if (valid_synchro==FALSE) lsynchro=0; // out of memory for synchro operations
else CPYMEM(lsynchro,pch_vms+MAKELONG(pb_vms,lsynchro,proccount,QV_SHORT),szl);
// set it the first time
unsigned char *psynchroinbuff;
if (gzplus==1) {
psynchroinbuff=lbuf-lsynchro+pbufuncompr;
//psynchroinbuff=pinterinbuff+lbuf-lsynchro-linter-lvms_add-lvers;
} else {
psynchroinbuff=NULL;
if (z_off_t zo=gzseek(ff,lbuf-lsynchro-linter-lvms_add-lvers,SEEK_CUR)==-1) {
sprintf(texterr,"Can't read from file %s addr=%ld size=%ld\n",
name,l,lbuf-lsynchro-linter-lvms_add-lvers);
valid=FALSE;
return;
}
}
if (lsynchro>0) {
l=gztell(ff);
// create array of synchronization times
try {
pclsyn[i]= new CSynchro(ff,lsynchro,psynchroinbuff);
if (pclsyn[i]==NULL) throw("Out of memory\n");
}
catch (bad_alloc e) {
valid_synchro=FALSE;
//lsynchro=0;
for (unsigned int j=0;j<=i;j++) {
if (pclsyn[j]!=NULL) {
pclsyn[j]->~CSynchro();
pclsyn[j]=NULL;
}
}
sprintf(textwarning[valid_warning],"Out of memory for synchronization operations\n");
valid_warning++;
} // end catch
catch (char *str) {
valid_synchro=FALSE;
//lsynchro=0;
for (unsigned int j=0;j<=i;j++) {
if (pclsyn[j]!=NULL) {
pclsyn[j]->~CSynchro();
pclsyn[j]=NULL;
}
}
sprintf(textwarning[valid_warning],"Out of memory for synchronization operations\n");
valid_warning++;
} // end catch
if (pclsyn[i]!=NULL) {
valid=pclsyn[i]->Valid();
if (!valid) {
pclsyn[i]->TextErr(texterr);
return;
}
} // end if
} else {
// synchronization times not accumulated
pclsyn[i]=0;
if (lsynchro >0 && gzplus==0) {
if (gzseek(ff,lsynchro,SEEK_CUR)!=0) {
valid=FALSE;
return;
}
}
}
if (gzplus==1) {delete []pbufcompr; pbufcompr=NULL;}
if (i!=proccount-1) {
if (gzplus==1) {
for (int k=0;;k++) {
if (gzread(ff,&(lbufplusch[k]),1)!=1) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s \n",name);
return;
}
if (lbufplusch[k]==0) break;
}
lbufcompr=atol(lbufplusch);
pbufcompr=new unsigned char[lbufcompr];
if (pbufcompr==NULL) throw("Out of memory\n");
s=gzread(ff,pbufcompr,lbufcompr);
if (s!=(int)lbufcompr) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s l=%ld\n",name,lbufcompr);
return;
}
int err=uncompress(pbufuncompr,&luncomprread,pbufcompr,lbufcompr);
if (err!=Z_OK || luncomprread!=lbufuncompr) {
valid=FALSE;
sprintf(texterr,"Can't uncompress l=%ld\n",lbufcompr);
return;
}
} else {
s=gzread(ff,&sz,sizeof(sz));
if (s!=sizeof(sz)) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s addr=%ld size=%d\n",
name,l,(int)sizeof(sz));
return;
}
s=gzread(ff,pch_vms,lvms);
if (s!=lvms) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s addr=%ld size=%d\n",
name,l,lvms);
return;
}
}
CPYMEM(rank,pch_vms+MAKESHORT(pb_vms,rank,rank),szsh);
if (gzplus==1) pch_vms=pbufuncompr+sizeof(sz);
else {
l=gztell(ff);
s=gzread(ff,pch_vmssize,szl*rank);
if (s!=szl*rank) {
valid=FALSE;
sprintf(texterr,"Can't read from file %s addr=%ld size=%d\n",
name,l,szl*rank);
return;
}
l=gztell(ff);
delete [] pvers; pvers=NULL;
}
}
}
if (gzplus==1) {delete []pbufuncompr; pbufuncompr=NULL;}
pic=new CInter*[proccount];
if (pic==NULL) throw("Out of memory\n");
// add synchronization times to interval characteristics
if (lsynchro>0) {
unsigned long n=BeginTreeWalk();
while (n!=0) {
BOOL b=Synchro();
if (b==1) return;
n=TreeWalk();
}
for (i=0;i<proccount;i++) {
pclsyn[i]->~CSynchro();
}
}//lsynchro
// sum interval characteristics
for (i=0;i<proccount;i++){
pclfrag[i]->SumLevel();
pclsyn[i]=NULL;
}
// Idle, Load imbalance
unsigned long n=BeginTreeWalk();
while (n!=0) {
double max=0.0,maxi=0.0;
double time,time1;
// calculate maximal values
for (i=0;i<proccount;i++) {
if (pic[i]!=NULL) {
pic[i]->ReadTime(EXEC,time);
if (time>max) max=time;
pic[i]->ReadTime(CPU,time);
pic[i]->ReadTime(CPUUSR,time1);
if (time+time1>maxi) maxi=time+time1;
}
}
// calculate maximal - current
for (i=0;i<proccount;i++) {
if (pic[i]!=NULL) {
double qproc;
pic[i]->ReadTime(PROC,qproc);
if (qproc!=n) {
// interval execute not on all processors
for (i=0;i<proccount;i++) {
if (pic[i]!=NULL) {
pic[i]->WriteTime(IDLE,0);
pic[i]->WriteTime(LOST,0);
pic[i]->WriteTime(IMB,0);
pic[i]->WriteTime(PROC,0);
}
}
break;
} else {
pic[i]->ReadTime(EXEC,time);
if (max-time>0.0) {
pic[i]->AddTime(IDLE,max-time);
pic[i]->AddTime(LOST,max-time);
}
pic[i]->ReadTime(CPU,time);
pic[i]->ReadTime(CPUUSR,time1);
if (maxi-time-time1>0.0)
pic[i]->AddTime(IMB,maxi-time-time1);
}
}
}
n=TreeWalk();
}
if (gzplus!=1) {
if (pch_vms!=NULL) {delete [] pch_vms;pch_vms=NULL;}
}
gzclose(ff);
}
//--------------------------------------------------
// deallocate memory for trees and syn times
CStatRead::~CStatRead(void)
{
if (pvers!=NULL) delete []pvers;
if (gzplus==1) {
if (pbufcompr!=NULL) delete []pbufcompr;
if (pbufuncompr!=NULL) delete []pbufuncompr;
} else {
if (pch_vms!=NULL) delete [] pch_vms;
}
if (pclfrag!=NULL) {
for (unsigned long i=0;i<proccount;i++) {
if (pclfrag[i]!=NULL) pclfrag[i]->~CTreeInter();
pclfrag[i]=NULL;
if (pic!=NULL) pic[i]=NULL;
if (pclsyn!=NULL) {
if (pclsyn[i]!=NULL) pclsyn[i]->~CSynchro();
pclsyn[i]=NULL;
}
}
delete [] pclfrag;
}
// deallocate memory for data-member
if (pclsyn!=NULL) delete [] pclsyn;
if (pch_vmssize!=NULL) delete []pch_vmssize;
if (pic!=NULL) delete [] pic;
}
//--------------------------------------------------
// begin tree-walk
unsigned long CStatRead::BeginTreeWalk(void)
// return number of intervals
{
unsigned long n=0;
for (unsigned long i=0;i<proccount;i++) {
pclfrag[i]->BeginInter();
pic[i]=NULL;
}
ident *id;
for(curnproc=0;curnproc<proccount;curnproc++) {
pclfrag[curnproc]->NextInter(&id);
if (id!=NULL) {
for (unsigned long j=0;j<proccount;j++) {
pic[j]=pclfrag[j]->FindInter(id);
if (pic[j]!=NULL) n++;
}
return(n);
}
}
return(n);
}
//------------------------------------------------
// continue tree-walk
unsigned long CStatRead::TreeWalk(void)
// return number of intervals
{
unsigned long n=0;
ident *id;
pclfrag[curnproc]->NextInter(&id);
if (id!=NULL) {
for (unsigned long j=0;j<proccount;j++) {
pic[j]=pclfrag[j]->FindInter(id);
if (pic[j]!=NULL) n++;
}
if (n!=0)return(n);
}
for(unsigned long i=curnproc+1;i<proccount;i++) {
pclfrag[i]->NextInter(&id);
if (id!=NULL) {
curnproc=i;
for (unsigned long j=0;j<proccount;j++) {
pic[j]=pclfrag[j]->FindInter(id);
if (pic[j]!=NULL) n++;
}
return(n);
}
}
return(n);
}
//------------------------------------------------
// calculate synchronization times, variation times and overlap
BOOL CStatRead::Synchro(void)
// return 0 - OK
{
unsigned long nint=0;
for (unsigned long k=0;k<proccount;k++) {
if (pic[k]!=NULL) {
// nint - number of current interval
nint=pic[k]->ninter;
BOOL b=pclsyn[k]->Count(nint,smallbuff);
if (b!=0) {
pclsyn[k]->TextErr(texterr);
valid=FALSE;
return(1);
}
}
}
if (nint==0) return(0);
for (short i=1;i<=QCOLLECT+QCOLLECT;i++) {
if ((i&3)!=0 && (i&3)!=2) { //4 type not used
typegrp t1;
typecom t2;
if (i<=QCOLLECT) {
t1=SYN;
t2=(typecom)((i)>>2);
}else{
t1=VAR;
t2=(typecom)((i-QCOLLECT)>>2);
}
int min=INT_MAX;
unsigned long j;
for (j=0;j<proccount;j++) {
if (pic[j]!=NULL) {
// n - number of times in the interval
int n=pclsyn[j]->GetCount((typecollect)(i));
if (min!=INT_MAX && n!=min && smallbuff==0) {
valid=FALSE;
sprintf(texterr,
"Number of synhro or variation times not equivalent on other processors %ld %ld numbers %d %d %\n",j+1,j,n,min);
return(1);
}
if (min>n) min=n;
}
}
if (min!=0) {
// times is accumulated
for ( int k=0; k<min; k++) {
double max=0.0;
// calculate maximal value
for (j=0;j<proccount;j++) {
if (pic[j]!=NULL) {
double time=pclsyn[j]->Find((typecollect)i);
if (time-max>0.0) max=time;
}
}
double maxs=0.0;
if (i<QCOLLECT && (i&3)==3) {
// overlap for wait_operation
for (j=0;j<proccount;j++) {
if (pic[j]!=NULL) {
double time=pclsyn[j]->FindNearest
((typecollect)(i+QCOLLECT-1)); //Start_operation
if (time==0.0 && smallbuff==0) {
valid=FALSE;
sprintf(texterr,"Number of call operations != number of wait operations\n");
return(1);
}
if (time-maxs>0.0) maxs=time;
}
}
}
for (j=0;j<proccount;j++) {
if (pic[j]!=NULL) {
double time=pclsyn[j]->GetCurr();
// write overlap
if (maxs>0.0 && time-maxs>0.0 ) {
pic[j]->AddTime(OVERLAP,t2,time-maxs);
}
// write syn and variation times
if (max-time>0.0) {
pic[j]->AddTime(t1,t2,max-time);
}
}
}
}
}
}
}
return(0);
}
//------------------------------------------------
// return result of constructor execution
BOOL CStatRead::Valid(int *warn)
{
*warn=valid_warning;
return(valid);
}
//---------------------------------------------------
// error message
void CStatRead::TextErr(char *t)
{
strcpy(t,texterr);
return;
}
// warning message
//---------------------------------------------------
// return number of processors
unsigned long CStatRead::QProc(void)
{
return(proccount);
}
//--------------------------------------------
// size of VMS
void CStatRead::VMSSize(char *str)
{
str[0]='\0';
char n[11];
long l=0;
for (int i=0;i<rank;i++) {
CPYMEM(l,pch_vmssize+i*szl,szl);
sprintf(n,"%ld",l);
if(i==rank-1) strcat(str,n);
else {
strcat(str,n);
strcat(str,"*");
}
}
}
//-----------------------------------------------
// warning message
void CStatRead::WasErrAccum(char *str)
{
if (valid_warning==0) str[0]='\0';
else {
strcpy(str,textwarning[valid_warning-1]);
valid_warning--;
}
return;
}
//---------------------------------------------
// return number of calls of collective operations
long CStatRead::ReadCall(typecom t)
{
double val=0.0;
long calll=0;
for (unsigned long i=0;i<proccount;i++) {
if (pic[i]!=NULL) {
double v;
pic[i]->ReadTime(CALL,t,v);
val=val+v;
}
}
calll=(long)(val/1);
if (val-calll!=0.0) calll++;
return(calll);
}
//---------------------------------------------
// identifier information of interval
// set number of current characteristics =0
// return number of level
short CStatRead::ReadTitle(char *str)
{
short nlev=0;
ident *id=NULL;
// nenter = number of enters / weight
double nenter=0.0;
for (unsigned long i=0;i<proccount;i++) {
if (pic[i]!=NULL) {
pic[i]->ReadIdent(&id);
nlev=id->nlev;
nenter=nenter+id->nenter;
}
}
long nent=(long)(nenter/1);
if (nenter-nent!=0.0) nent++;
char type[10];
switch((int)(id->t)) {
case REDUC:strcpy(type,"REDUC");
break;
case SREDUC:strcpy(type,"SREDUC");
break;
case WREDUC:strcpy(type,"WREDUC");
break;
case SHAD:strcpy(type,"SHAD");
break;
case SSHAD:strcpy(type,"SSHAD");
break;
case WSHAD:strcpy(type,"WSHAD");
break;
case RACC:strcpy(type,"RACC");
break;
case SRACC:strcpy(type,"SRACC");
break;
case WRACC:strcpy(type,"WRACC");
break;
case REDISTR:strcpy(type,"REDISTR");
break;
case SREDISTR:strcpy(type,"SREDISTR");
break;
case WREDISTR:strcpy(type,"WREDISTR");
break;
case PREFIX:strcpy(type,"PREFIX");
break;
case SEQ:strcpy(type,"SEQ");
break;
case PAR: strcpy(type,"PAR");
break;
case USER: strcpy(type,"USER");
break;
default: sprintf(str,"Statread ReadTitle:Incorrect type\n");
return(0);
}
if (id->nlev==0) type[0]='\0';
if (id->pname==NULL) {
if (id->expr==Fic_index)
sprintf(str,"INTERVAL ( NLINE=%ld ) LEVEL=%d %s EXE_COUNT=%ld\n",
id->nline,id->nlev,type,nent);
else sprintf(str,"INTERVAL ( NLINE=%ld ) LEVEL=%d %s EXE_COUNT=%ld EXPR=%ld\n",
id->nline,id->nlev,type,nent,id->expr);
}else {
if (id->expr==Fic_index)
sprintf(str,"INTERVAL ( NLINE=%ld SOURCE=%s ) LEVEL=%d %s EXE_COUNT=%ld\n",
id->nline,id->pname,id->nlev,type,nent);
else sprintf(str,"INTERVAL ( NLINE=%ld SOURCE=%s ) LEVEL=%d %s EXE_COUNT=%ld EXPR=%ld\n",
id->nline,id->pname,id->nlev,type,nent,id->expr);
}
curntime=0;
return(nlev);
}
//--------------------------------------------------------
// return version number on accumulation
char *CStatRead::ReadVers(void)
{
return(pvers);
}
//--------------------------------------------------------
// return platform information on accumulation
char *CStatRead::ReadPlatform(void)
{
return(pvers+strlen(pvers)+1);
}
//-----------------------------------------------------------
//name and time of processor
void CStatRead::NameTimeProc(unsigned long n,char **name,double *time)
{
pclfrag[n]->ReadProcName(name);
pclfrag[n]->ReadProcTime(*time);
return;
}
//-------------------------------------------------------
// read current time characteristics
// use after ReadTitle()
BOOL CStatRead::ReadProc(typeprint t,unsigned long *pnumb,int qnumb,short fmt,
double sum,char *str)
//t - type of information of characteristics for each processor,
//pnumb - pointer to array of processor numbers, for which characteristics are to be output,
//qnumb - number of elements of processor number array,
//sum - total characteristic value for each processor,
//str - string where characteristic name and time values are written.
{
int q,prec,lstr;
if (t==PRGEN) q=ITER;else q=RED;
//char ss[1024];
curntime++;
if (sum==0.0) {
str[0]='\0';
if (curntime>q) curntime=0;
return(TRUE);
}
if (t==PRGEN) {
sprintf(str,"%s",nameGen[curntime-1]);
//sprintf(ss,"%s",nameGen[curntime-1]);
} else {
// nameCom for VAR,OVERLAP,SYN,COM,RCOM
sprintf(str,"%s",nameCom[curntime-1]);
strcat(str," ");
}
lstr=strlen(nameGen[curntime-1]);
// list of processor numbers - pnumb
// pr=TRUE - number is in list
for (unsigned long i=0;i<proccount;i++) {
BOOL pr=FALSE;
if (pic[i]!=NULL) {
if (pnumb!=NULL) {
for (int j=0;j<qnumb;j++) {
if (i+1>=pnumb[j] && i+1<=pnumb[j+1]) pr=TRUE;
}
} else pr=TRUE;
if (pr==TRUE) {
// read time characteristic
double time;
switch (t) {
case PRGEN:
pic[i]->ReadTime((typetime)(curntime-1),time);
break;
case PRCOM:
pic[i]->ReadTime(COM,(typecom)(curntime-1),time);
break;
case PRRCOM:
pic[i]->ReadTime(RCOM,(typecom)(curntime-1),time);
break;
case PRSYN:
pic[i]->ReadTime(SYN,(typecom)(curntime-1),time);
break;
case PRVAR:
pic[i]->ReadTime(VAR,(typecom)(curntime-1),time);
break;
case PROVER:
pic[i]->ReadTime(OVERLAP,(typecom)(curntime-1),time);
break;
default:sprintf(str,"Statread ReadProc:Incorrect type=%d\n",t);
return(FALSE);
}
if ((t==PRGEN) && ((typetime)(curntime-1)==PROC ||
(typetime)(curntime-1)==ITER)) prec=0;else prec=PREC;
sprintf((str+lstr),"%*.*lf ",fmt,prec,time);
//sprintf(ss+lstr,"%*.*lf",fmt,prec,time);
lstr=strlen(str);
}
}
}
if (curntime>q) curntime=0;
return(TRUE);
}
//--------------------------------------------------------
// calculate min,max,sum time characteristics
void CStatRead::MinMaxSum(typeprint t,double *min,unsigned long *nprocmin,
double*max,unsigned long *nprocmax,
double *sum)
// t - characteristic type,
//min - pointer to array of minimal characteristic values,
//nprocmin,- pointer to processor number array, corresponding to minimal values,
//max, - pointer to array of maximal characteristic values,
//nprocmax, - pointer to processor number array, corresponding to maximal values,
//sum - pointer to array of total characteristic values.
{
int q;
if (t==PRGEN) q=ITER;else q=RED;
if (t==PRCALLS || t==PRLOST) q=StatGrpCount-1;
int k;
for (k=0;k<=q;k++) {
min[k]=DBL_MAX;
max[k]=0.0;
sum[k]=0.0;
nprocmin[k]=0;
nprocmax[k]=0;
}
for (unsigned long i=0;i<proccount;i++) {
if (pic[i]!=NULL) {
for (k=0;k<=q;k++) {
double time;
// read time characteristic
switch (t) {
case PRGEN:
pic[i]->ReadTime((typetime)k,time);
break;
case PRCOM:
pic[i]->ReadTime(COM,(typecom)k,time);
break;
case PRRCOM:
pic[i]->ReadTime(RCOM,(typecom)k,time);
break;
case PRSYN:
pic[i]->ReadTime(SYN,(typecom)k,time);
break;
case PRVAR:
pic[i]->ReadTime(VAR,(typecom)k,time);
break;
case PRCALLS:
pic[i]->ReadTime(CALLSMT,k,time);
break;
case PRLOST:
pic[i]->ReadTime(LOSTMT,k,time);
break;
case PROVER:
pic[i]->ReadTime(OVERLAP,(typecom)k,time);
break;
default:
valid=FALSE;
printf("CStatRead::MinMaxSum Unknown typeprint=%d\n",t);
return;
}
// minimal value
if (min[k]>time) {
min[k]=time;
nprocmin[k]=i+1;
}
//maximal value
if (max[k]<=time) {
max[k]=time;
nprocmax[k]=i+1;
}
// sum value
sum[k]=sum[k]+time;
}
}
}
}
//-------------------------------------------------------------------------
// read grp characteristics
void CStatRead::GrpTimes(double *arrprod,double *arrlost,double *arrcalls,int nproc)
{
int q=StatGrpCount-1;
int k;
for (k=0;k<=q;k++) {
arrprod[k]=0.0;
arrlost[k]=0.0;
arrcalls[k]=0.0;
}
unsigned long i=nproc-1;
//double arr[StatGrpCount];
if (pic[i]!=NULL) {
for (k=0;k<=q;k++) {
// read time characteristic
pic[i]->ReadTime(CALLSMT,k,arrcalls[k]);
//arrcalls[k]=(int)arr[k];
pic[i]->ReadTime(LOSTMT,k,arrlost[k]);
pic[i]->ReadTime(PRODMT,k,arrprod[k]);
} // end for
}// end if
return;
}
Reference in New Issue Copy Permalink