#define _STATFILE_
#include "inter.h"
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
// calculate execution characteristics for interval
CInter::CInter(s_GRPTIMES (*pt)[StatGrpCount],s_SendRecvTimes ps,
			   ident id,unsigned long nint,
			   int iIM,int jIM,short sore)
 //(*pt)[StatGrpCount] - pointer to time array,it reading from file,
 // ps                 - pointer to add info
 //id                  - interval identifier,
 //nint                - interval number.
{
	//identifire interval information
	if (id.pname[0]!='\0') {
		idint.pname=new char[strlen(id.pname)+1];
        if (idint.pname==NULL) throw("Out of memory\n");
	}
	else idint.pname=NULL;
	if (idint.pname!=NULL) strcpy(idint.pname,id.pname);// name of DVM-programm
	idint.nline=id.nline; // number of DVM-programm line
        idint.nline_end=id.nline_end; // number of end of DVM-programm line
	idint.nenter=id.nenter; // number of enters into the interval
	idint.expr=id.expr; // conditional expession
	idint.nlev=id.nlev; // number of interval level
	idint.t=id.t; // type of interval
	ninter=nint;
	idint.proc=id.proc; // number of processors
	// arrays of collective operation times
	int i;
	for ( i=0;i<=ITER;i++) mgen[i]=0.;
	for (i=0;i<=RED;i++) {
		mcom[i]=0.;
		mrcom[i]=0.;
		msyn[i]=0.;
		mvar[i]=0.;
		mcall[i]=0.;
		moverlap[i]=0.;
	}
	for(i=0;i<StatGrpCount;i++) {
		lost[i]=0.;
		calls[i]=0.;
		prod[i]=0.;
	}
	// execution characteristics on each processor
	for (i=0;i<StatGrpCount;i++) {
		mgen[SUMCOM]=mgen[SUMCOM]+pt[i][MsgPasGrp].LostTime;
		mgen[SUMRCOM]=mgen[SUMRCOM]+pt[i][MsgPasGrp].ProductTime;
		mgen[CPUUSR]=mgen[CPUUSR]+pt[i][UserGrp].ProductTime;
		mgen[INSUFUSR]=mgen[INSUFUSR]+pt[i][UserGrp].LostTime;
		mgen[IOTIME]=mgen[IOTIME]+pt[i][IOGrp].ProductTime;
		for (int j=0;j<StatGrpCount;j++) {
			/*if (i==UserGrp) {
				mgen[CPUUSR]=mgen[CPUUSR]+pt[UserGrp][j].ProductTime;
                mgen[INSUFUSR]=mgen[INSUFUSR]+pt[UserGrp][j].LostTime;
			}
			if (i==IOGrp) mgen[IOTIME]=mgen[IOTIME]+pt[IOGrp][j].ProductTime;*/
			mgen[EXEC]=mgen[EXEC]+pt[i][j].ProductTime+pt[i][j].LostTime;
			mgen[INSUF]=mgen[INSUF]+pt[i][j].LostTime;
			mgen[CPU]=mgen[CPU]+pt[i][j].ProductTime;
		} // end for j
	}
	mgen[EXEC]=mgen[EXEC]-mgen[SUMRCOM];
	mgen[CPU]=mgen[CPU]-mgen[CPUUSR]-mgen[SUMRCOM]-mgen[IOTIME];
	mgen[INSUF]=mgen[INSUF]-mgen[INSUFUSR]-mgen[SUMCOM];
	//real synchronization,number of calls, communication
	// reduction
	mcom[RD]=pt[WaitRedGrp][MsgPasGrp].LostTime+
		pt[StartRedGrp][MsgPasGrp].LostTime;
	mrcom[RD]=pt[WaitRedGrp][MsgPasGrp].ProductTime;
	mcall[RD]=pt[UserGrp][WaitRedGrp].CallCount;
	// shadow
	mcom[SH]=pt[WaitShdGrp][MsgPasGrp].LostTime+
		pt[DoPLGrp][MsgPasGrp].LostTime+
		pt[StartShdGrp][MsgPasGrp].LostTime;
	mrcom[SH]=pt[WaitShdGrp][MsgPasGrp].ProductTime+
		pt[DoPLGrp][MsgPasGrp].ProductTime;
	mcall[SH]=pt[UserGrp][WaitShdGrp].CallCount;
	// remote access
	mcom[RA]=pt[RemAccessGrp][MsgPasGrp].LostTime;
	mrcom[RA]=pt[RemAccessGrp][MsgPasGrp].ProductTime;
	mcall[RA]=pt[UserGrp][RemAccessGrp].CallCount;
	// redistribute
	mcom[RED]=pt[ReDistrGrp][MsgPasGrp].LostTime;
	mrcom[RED]=pt[ReDistrGrp][MsgPasGrp].ProductTime;
	mcall[RED]=pt[UserGrp][ReDistrGrp].CallCount;
	// input/output
	mcom[IO]=pt[IOGrp][MsgPasGrp].LostTime;
	mrcom[IO]=pt[IOGrp][MsgPasGrp].ProductTime;
	mcall[IO]=pt[UserGrp][IOGrp].CallCount;
	// add information
	SendCallTime=ps.SendCallTime;
	MinSendCallTime=ps.MinSendCallTime;
	MaxSendCallTime=ps.MaxSendCallTime;
	SendCallCount=ps.SendCallCount;
	RecvCallTime=ps.RecvCallTime;
	MinRecvCallTime=ps.MinRecvCallTime;
	MaxRecvCallTime=ps.MaxRecvCallTime;
	RecvCallCount=ps.RecvCallCount;
	mgen[START]=SendCallTime+RecvCallTime;
	// time array
	//int j=USERGRP;
	if (iIM!=0) {
		for (i=0;i<StatGrpCount;i++) {
			if (sore==1) {//sum
				for (int k=0;k<StatGrpCount; k++) {
					//mgen[j]=mgen[j]+pt[i][k].ProductTime;
					lost[i]=lost[i]+pt[i][k].LostTime;
					prod[i]=prod[i]+pt[i][k].ProductTime;
					calls[i]=calls[i]+pt[i][k].CallCount;
				}
			}else {
				//mgen[j]=pt[iIM-1][i].ProductTime;
				lost[i]=pt[iIM-1][i].LostTime;
				prod[i]=pt[iIM-1][i].ProductTime;
				calls[i]=pt[iIM-1][i].CallCount;
			}
		}
	}
	if (jIM!=0) {
		for (i=0;i<StatGrpCount;i++) {
			if (sore==1) {
				for (int k=0;k<StatGrpCount;k++) {
					//mgen[j]=mgen[j]+pt[k][i].ProductTime;
					prod[i]=prod[i]+pt[k][i].ProductTime;
					lost[i]=lost[i]+pt[k][i].LostTime;
					calls[i]=calls[i]+pt[k][i].CallCount;
				}
			} else {
				//mgen[j]=pt[i][jIM-1].ProductTime;
				prod[i]=pt[i][jIM-1].ProductTime;
				lost[i]=pt[i][jIM-1].LostTime;
				calls[i]=pt[i][jIM-1].CallCount;
			}
		//j++;
		}
	}
}
//-------------------------------------------------
// deallocate memory for name of DVM-program
CInter::~CInter()
{
	if (idint.pname!=NULL) delete []idint.pname;
}
//--------------------------------------------------
// addition execution time characteristics
void CInter::AddTime(typetime t2,double val)
//t2 - type of execution characteristics
// val - additional value
{
#ifdef _DEBUG
	if (t2<0 || t2>ITER) {
		printf("CInter AddTime incorrect typetime %d\n",t2);
		return;
	}
#endif
	mgen[t2]=mgen[t2]+val;
}
//--------------------------------------------------
//write new execution time characteristics
void CInter::WriteTime(typetime t2,double val)
//t2 - type of execution characteristics
// val - new value
{
#ifdef _DEBUG
	if (t2<0 || t2>ITER) {
		printf("CInter WriteTime incorrect typetime %d\n",t2);
		return;
	}
#endif
	mgen[t2]=val;
}
//-------------------------------------------------
// read execution time characteristics
void CInter::ReadTime(typetime t2,double &val)
//t2 - type of execution characteristics
// val - answer
{
#ifdef _DEBUG
	if (t2<0 || t2>ITER) {
		printf("CInter ReadTime incorrect typetime %d\n",t2);
		return;
	}
#endif
	val=mgen[t2];
}
//--------------------------------------------------
// addition times of collective operations
void CInter::AddTime(typegrp t1,typecom t2,double val)
//t1 - type of communication operation
//t2 - type of collective operation
//val - additional value 
{
#ifdef _DEBUG
	if (t2<0 || t2>RED) {
			printf("CInter AddTime incorrect typecom %d\n",t2);
		return;
	}
#endif
	switch (t1) {
		case COM:
			mcom[t2]=mcom[t2]+val;
			break;
		case RCOM:
			mrcom[t2]=mrcom[t2]+val;
			break;
		case SYN :
			msyn[t2]=msyn[t2]+val;
			break;
		case VAR:
			mvar[t2]=mvar[t2]+val;
			break;
		case CALL:
			mcall[t2]=mcall[t2]+val;
			break;
		case OVERLAP:
			moverlap[t2]=moverlap[t2]+val;
			break;
		default:
			printf("CInter WriteCom incorrect typegrp\n");
			break;
	}
}
//---------------------------------------------------
// read communication collective operations time
void CInter::ReadTime(typegrp t1,typecom t2,double &val)
//t1 - type of communication operation
//t2 - type of collective operation
//val - answer 
{
#ifdef _DEBUG
	if (t2<0 || t2>RED) {
			printf("CInter ReadTime incorrect typecom %d\n",t2);
		return;
	}
#endif
	switch (t1) {
		case COM:
			val=mcom[t2];
			break;
		case RCOM:
			val=mrcom[t2];
			break;
		case SYN :
			val=msyn[t2];
			break;
		case VAR:
			val=mvar[t2];
			break;
		case CALL:
			val=mcall[t2];
			break;
		case OVERLAP:
			val=moverlap[t2];
			break;
		default:
			printf("CInter ReadTime incorrect typegrp\n");
			break;
	}
}
//---------------------------------------------------
// read time from interval matrix
void CInter::ReadTime(typetimeim t1,int t2,double &val)
//t1 - type of time (lost/number of calls)
//t2 - index
//val - answer
 
{
#ifdef _DEBUG
	if (t2<0 || t2>=StatGrpCount) {
		printf("CInter ReadTime incorrect 2 parameter %d\n",t2);
		return;
	}
#endif
	switch (t1) {
		case CALLSMT:
			val=calls[t2];
			break;
		case LOSTMT:
			val=lost[t2];
			break;
		case PRODMT:
			val=prod[t2];
			break;
		default:
			printf("CInter ReadTime incorrect type of im time\n");
			break;
	}
}
//-----------------------------------------------------
// compare identifier information on other processors
int CInter::CompIdent(ident *p)
//p - pointer identifire information
{
	if ((idint.pname==NULL || (strcmp(p->pname,idint.pname)==0)) && (p->nline==idint.nline) &&
	(p->nlev==idint.nlev) &&  (p->expr==idint.expr) && 	(p->t==idint.t)) {
		return(1);
	}
	return(0);
}
//------------------------------------------------------
// read identifier information
void CInter::ReadIdent(ident **p)
{
	*p=&idint;
}
//-----------------------------------------------------
// sum times characteristics upon levels
void CInter::SumInter(CInter *p)
{
	int i;
	for (i=0;i<=RED;i++) {
		mgen[SUMSYN]=mgen[SUMSYN]+msyn[i];
		mgen[SUMVAR]=mgen[SUMVAR]+mvar[i];
		mgen[SUMOVERLAP]=mgen[SUMOVERLAP]+moverlap[i];
	}
	mgen[PROC]=(double)idint.proc;
	if (idint.proc!=0) {
		mgen[LOST]=mgen[INSUF]+mgen[INSUFUSR]+mgen[IDLE]+mgen[SUMCOM];
	}
	if (p==NULL) return;
	for (i=0;i<=ITER;i++) {
		if (i<SUMSYN || i>SUMOVERLAP) p->mgen[i]=p->mgen[i]+mgen[i];
	}
	for (i=0;i<StatGrpCount;i++) {
		p->lost[i]=p->lost[i]+lost[i];
		p->prod[i]=p->prod[i]+prod[i];
		p->calls[i]=p->calls[i]+calls[i];
	}
	// add information
	p->SendCallTime=p->SendCallTime+SendCallTime;
	p->MinSendCallTime=p->MinSendCallTime+MinSendCallTime;
	p->MaxSendCallTime=p->MaxSendCallTime+MaxSendCallTime;
	p->SendCallCount=p->SendCallCount+SendCallCount;
	p->RecvCallTime=p->RecvCallTime+RecvCallTime;
	p->MinRecvCallTime=p->MinRecvCallTime+MinRecvCallTime;
	p->MaxRecvCallTime=p->MaxRecvCallTime+MaxRecvCallTime;
	p->RecvCallCount=p->RecvCallCount+RecvCallCount;
	// sum communication information
	for (i=0;i<=RED;i++) {
		p->mcom[i]=p->mcom[i]+mcom[i];
		p->mrcom[i]=p->mrcom[i]+mrcom[i];
		p->msyn[i]=p->msyn[i]+msyn[i];
		p->mvar[i]=p->mvar[i]+mvar[i];
		p->moverlap[i]=p->moverlap[i]+moverlap[i];
		p->mcall[i]=p->mcall[i]+mcall[i];
	}
}
//-----------------------------------------------------