#define _STATFILE_
#include "treeinter.h"
#include <stdio.h>
#include <string.h>
#include "dvmh_stat.h"

// @todo! ПРОВЕРИТЬ БЕЗ GZ+

extern short reverse,szsh,szd,szv,szl,torightto,torightfrom;
// list of intervals for each processor
CTreeInter::CTreeInter(gzFile stream,unsigned long lint,char *pbuff,
					   unsigned int n,unsigned long qint,short maxn,
					   char * ppn,double proct,
					   int iIM,int jIM,short sore,
					   unsigned char *pbuffer,
					   dvmh_stat_header *dvmhStatHeader)
// stream-file descriptor pointer,
//lint- information length in bytes,
// pbuff - beginning of the buffer at the collection stage,
//n - processor number,
//qint - number of intervals
//maxn - maximal nesting level
// ppn - processor name
// proct - processor time
//iIm- 0/1 sign of summing on index i
//jIM-0/1 sign of summing on index j
//sore - sign of summing or elements print
//pbuffer - file gz+,data have been read
{
	valid=TRUE;
	nproc=n;
	qinter=qint;
	maxnlev=maxn;
	curninter=1;
	pt=NULL;
	pprocname=NULL;
	sign_buffer=NULL;
	unsigned char *buffer;

	// -- dvmh
	this->dvmhStatHeader = dvmhStatHeader;
	// --

	if (ppn!=NULL) {// processor name
		if (dvmhDebug) { printf("   Process name: %s\n", ppn); fflush(stdout); }
		pprocname=new char[strlen(ppn)+1];
		if (pprocname==NULL) throw("Out of memory\n");
		strcpy(pprocname,ppn);
	}

	proctime=proct;
	// dynamically allocate memory for intervals of struct tinter_ch
	if (pbuffer==NULL) { //data had not been read
		buffer=new unsigned char[lint];
		if (buffer==NULL) throw("Out of memory\n");
		sign_buffer=buffer;
		long l=gztell(stream);
		// read interval information from file
		int s=gzread(stream,buffer,lint);
		if ((unsigned long)s!=lint) {
			valid=FALSE;
			sprintf(texterr,"Can't read intervals from file, addr=%ld, length=%ld\n",
					l,lint);
			delete []sign_buffer;
			sign_buffer=NULL;
			return;
		}
	} else buffer=pbuffer;

	unsigned char *pch=buffer;
	pinter *pi=NULL;

	// allocate memory for intervals of struct ttree
	pt=new ptree[qinter];
	if (pt==NULL) throw("Out of memory\n");
	ident id;
	// calculate size of interval without name of DVM-programm

	unsigned long offsetDvmhStat = QI_SHORT*szsh+QI_LONG*szl+QI_VOID*szv+QI_DOUBLE*szd; // -- dvmh
//	int lintone = QI_SHORT*szsh+QI_LONG*szl+QI_VOID*szv+QI_DOUBLE*szd + this->dvmhStatHeader->sizeIntervalConstPart; // -- dvmh
	int commonLengthForInterval=QI_SHORT*szsh+QI_LONG*szl+QI_VOID*szv+QI_DOUBLE*szd + this->dvmhStatHeader->sizeIntervalConstPart; // -- dvmh
	int extraLengthForThreads = 0;

	s_GRPTIMES times[StatGrpCount][StatGrpCount];
	int a=MAKEDOUBLE(pi,times[0],nenter,QI_SHORT,QI_LONG,QI_VOID);
	a=MAKELONG(pi,nline,nline,QI_SHORT);

	for (unsigned long ll=0;ll<qinter;ll++) {
		int lt=0;
		// copy time characteristics from file
		for (int i=0;i<StatGrpCount;i++) {
			for (int j=0;j<StatGrpCount;j++) {
				times[i][j].CallCount=0.0; times[i][j].ProductTime=0.0; times[i][j].LostTime=0.0;
				CPYMEM(times[i][j].CallCount,
					   pch+MAKEDOUBLE(pi,times[lt],nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
				CPYMEM(times[i][j].ProductTime,
					   pch+MAKEDOUBLE(pi,times[lt+1],nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
				CPYMEM(times[i][j].LostTime,
					   pch+MAKEDOUBLE(pi,times[lt+2],nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
				lt=lt+3;
			}
		}
		// add information to interval matrix
		s_SendRecvTimes addinfo;
		addinfo.SendCallTime=0.0;
		addinfo.MinSendCallTime=0.0;
		addinfo.MaxSendCallTime=0.0;
		addinfo.SendCallCount=0;
		addinfo.RecvCallTime=0.0;
		addinfo.MinRecvCallTime=0.0;
		addinfo.MaxRecvCallTime=0.0;
		addinfo.RecvCallCount=0;
		CPYMEM(addinfo.SendCallTime,pch+MAKEDOUBLE(pi,SendCallTime,nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
		CPYMEM(addinfo.MinSendCallTime,pch+MAKEDOUBLE(pi,MinSendCallTime,nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
		CPYMEM(addinfo.MaxSendCallTime,pch+MAKEDOUBLE(pi,MaxSendCallTime,nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
		CPYMEM(addinfo.SendCallCount,pch+MAKELONG(pi,SendCallCount,nline,QI_SHORT),szl);
		CPYMEM(addinfo.RecvCallTime,pch+MAKEDOUBLE(pi,RecvCallTime,nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
		CPYMEM(addinfo.MinRecvCallTime,pch+MAKEDOUBLE(pi,MinRecvCallTime,nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
		CPYMEM(addinfo.MaxRecvCallTime,pch+MAKEDOUBLE(pi,MaxRecvCallTime,nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
		CPYMEM(addinfo.RecvCallCount,pch+MAKELONG(pi,RecvCallCount,nline,QI_SHORT),szl);

		// -- dvmh
		dvmh_stat_interval *dvmhStatInterval = this->readDvmhStat(pch + offsetDvmhStat);
		extraLengthForThreads = dvmhStatHeader->threadsAmount * sizeof(dvmh_stat_interval_thread);
		// --
		int allLengthForInterval = commonLengthForInterval + extraLengthForThreads;

		
	//	id.pname=(char *)(pch + lintone);
		id.pname=(char *)(pch + allLengthForInterval);
		// copy identifier information
		id.nline=0; id.nline_end=0; id.proc=0;id.nenter=0; id.expr=0;id.nlev=0;
		CPYMEM(id.nline,pch+MAKELONG(pi,nline,nline,QI_SHORT),szl);
		CPYMEM(id.nline_end,pch+MAKELONG(pi,nline_end,nline,QI_SHORT),szl);
		CPYMEM(id.proc,pch+MAKELONG(pi,qproc,nline,QI_SHORT),szl);
		CPYMEM(id.nlev,pch+MAKESHORT(pi,nlev,nlev),szsh);
		CPYMEM(id.expr,pch+MAKELONG(pi,expr,nline,QI_SHORT),szl);
		CPYMEM(id.nenter,pch+MAKEDOUBLE(pi,nenter,nenter,QI_SHORT,QI_LONG,QI_VOID),szd);
		short sh=0;
		CPYMEM(sh,pch+MAKESHORT(pi,type,nlev),szsh);
		id.t=(typefrag)sh;
		unsigned char *pptr=NULL;
		unsigned long l0=0;
		// copy referenses on up, down and next intervals
		CPYMEM(pptr,pch+MAKEVOID(pi,up,up,QI_SHORT,QI_LONG),szv);
		if (pptr==NULL) {
			memcpy(&pt[ll].up,&l0,sizeof(l0));
		} else {
			long l=(char*)pptr-pbuff;
			pptr=buffer+l;
			pt[ll].up=0;
			CPYMEM(pt[ll].up,pptr+MAKELONG(pi,ninter,nline,QI_SHORT),szl);
		}
		pptr=NULL;
		CPYMEM(pptr,pch+MAKEVOID(pi,down,up,QI_SHORT,QI_LONG),szv);
		if (pptr==NULL) {memcpy(&pt[ll].down,&l0,sizeof(l0));
		} else {
			long l=(char*)pptr-pbuff;
			pptr=buffer+l;
			pt[ll].down=0;
			CPYMEM(pt[ll].down,pptr+MAKELONG(pi,ninter,nline,QI_SHORT),szl);
		}
		pptr=NULL;
		CPYMEM(pptr,pch+MAKEVOID(pi,next,up,QI_SHORT,QI_LONG),szv);
		if (pptr==NULL) {memcpy(&pt[ll].next,&l0,sizeof(l0));
		} else {
			long l=(char *)pptr-pbuff;
			pptr=buffer+l;
			pt[ll].next=0;
			CPYMEM(pt[ll].next,pptr+MAKELONG(pi,ninter,nline,QI_SHORT),szl);
		}
		// time characteristics for each interval
		pt[ll].pint=new CInter(times,addinfo,id,ll+1,iIM,jIM,sore, dvmhStatInterval);
		if (pt[ll].pint==NULL) throw("Out of memory\n");

	//	pch = pch + lintone + 1 + strlen((char*)(pch + lintone));
		pch = pch + allLengthForInterval + 1 + strlen((char*)(pch + allLengthForInterval));
	}
	if (sign_buffer!=NULL) {delete []sign_buffer; sign_buffer=NULL;}
	return;
}

unsigned long CTreeInter::memAlign(unsigned long pointer, const unsigned short align, const unsigned long size) {
	unsigned long p = pointer;
	if (align - p % align < size)
		while (p % align) p++;
	//printf("          memAlign %u -> %u (%u) rest %u\n", pointer, p, size, align - p % align);
	return p;
}

dvmh_stat_interval *CTreeInter::readDvmhStat(unsigned char * const buffer) {
	dvmh_stat_interval            *dvmhStatInterval;
	dvmh_stat_interval_gpu        *dvmhStatGpu;
	dvmh_stat_interval_gpu_metric *dvmhStatMetric;


	unsigned long dvmhStatShift = 0;
	unsigned long t, t2; /*@todo del */
	int dvmh_i, dvmh_j;

	dvmhStatInterval = new dvmh_stat_interval();
	if (!dvmhStatInterval) throw("Out of memory\n");

	// Инициализируем аккумулируемые времена
	dvmhStatInterval->allGPUTimeProductive = 0.0f;
	dvmhStatInterval->allGPUTimeLost       = 0.0f;
	dvmhStatInterval->allThreadsUserTime   = 0.0f;
	dvmhStatInterval->allThreadsSystemTime = 0.0f;

	CPYMEM(dvmhStatInterval->mask, buffer + dvmhStatShift, szl);
	if (dvmhDebug) { printf("Mask: %lu (%u)\n", dvmhStatInterval->mask, dvmhStatShift); fflush(stdout); }
	dvmhStatShift += szl;

	dvmhStatInterval->threads = new dvmh_stat_interval_thread[dvmhStatHeader->threadsAmount];
        if(!(dvmhStatInterval->threads)) throw ("Out of memory\n");

	// Читаем информацию по каждому GPU
	for (dvmh_i = 0; dvmh_i < DVMH_STAT_MAX_GPU_CNT; ++dvmh_i) {
		dvmhStatGpu = & (dvmhStatInterval->gpu[dvmh_i]);
		if (dvmhDebug) { printf("   GPU: %lu (%u)\n", dvmh_i, dvmhStatShift); fflush(stdout); }
		t2 = dvmhStatShift;

		// Инициализируем аккумулируемые времена GPU
		dvmhStatGpu->timeProductive = 0.0f;
		dvmhStatGpu->timeLost       = 0.0f;

		if (dvmhDebug) { printf("        gpuTimeProductive: %.4f\n", dvmhStatGpu->timeProductive); fflush(stdout); }
		if (dvmhDebug) { printf("        gpuTimeLost      : %.4f\n", dvmhStatGpu->timeLost); fflush(stdout); }

		// Copy metrics
		for (dvmh_j = 0; dvmh_j < DVMH_STAT_METRIC_CNT; ++dvmh_j) {
			t = dvmhStatShift;
			dvmhStatMetric = & (dvmhStatGpu->metrics[dvmh_j]);
			if (dvmhDebug) { printf("      Metric: %d (%u)\n", dvmh_j, dvmhStatShift); fflush(stdout); }

			CPYMEM(dvmhStatMetric->isReduced, buffer+dvmhStatShift, szsh);
			if (dvmhDebug) { printf("        isReduced     : %d (%u)\n", dvmhStatMetric->isReduced,dvmhStatShift); fflush(stdout); }
			dvmhStatShift += szsh;

			CPYMEM(dvmhStatMetric->hasOwnMeasures, buffer+dvmhStatShift, szsh);
			if (dvmhDebug) { printf("        hasOwnMeasures: %d (%u)\n", dvmhStatMetric->hasOwnMeasures,dvmhStatShift); fflush(stdout); }
			dvmhStatShift += szsh;

			CPYMEM(dvmhStatMetric->countMeasures, buffer+dvmhStatShift, szl);
			if (dvmhDebug) { printf("        countMeasures : %d (%u)\n", dvmhStatMetric->countMeasures,dvmhStatShift); fflush(stdout); }
			dvmhStatShift += szl;

			CPYMEM(dvmhStatMetric->timeProductive, buffer+dvmhStatShift, szd);
			if (dvmhDebug) { printf("        timeProductive: %.4f (%u)\n", dvmhStatMetric->timeProductive,dvmhStatShift); fflush(stdout); }
			dvmhStatShift += szd;

			CPYMEM(dvmhStatMetric->timeLost, buffer+dvmhStatShift, szd);
			if (dvmhDebug) { printf("        timeLost      : %.4f (%u)\n", dvmhStatMetric->timeLost,dvmhStatShift); fflush(stdout); }
			dvmhStatShift += szd;

			CPYMEM(dvmhStatMetric->min, buffer+dvmhStatShift, szd);
			if (dvmhDebug) { printf("        min           : %.4f (%u)\n", dvmhStatMetric->min,dvmhStatShift); fflush(stdout); }
			dvmhStatShift += szd;

			CPYMEM(dvmhStatMetric->mean, buffer+dvmhStatShift, szd);
			if (dvmhDebug) { printf("        mean          : %.4f (%u)\n", dvmhStatMetric->mean,dvmhStatShift); fflush(stdout); }
			dvmhStatShift += szd;

			CPYMEM(dvmhStatMetric->max, buffer+dvmhStatShift, szd);
			if (dvmhDebug) { printf("        max           : %.4f (%u)\n", dvmhStatMetric->max,dvmhStatShift); fflush(stdout); }
			dvmhStatShift += szd;

			CPYMEM(dvmhStatMetric->sum, buffer+dvmhStatShift, szd);
			if (dvmhDebug) { printf("        sum           : %.4f (%u)\n", dvmhStatMetric->sum,dvmhStatShift); fflush(stdout); }
			dvmhStatShift += szd;

            #if DVMH_EXTENDED_STAT == 1
            CPYMEM(dvmhStatMetric->q1, buffer+dvmhStatShift, szd);
			if (dvmhDebug) { printf("        q1            : %.4f (%u)\n", dvmhStatMetric->q1,dvmhStatShift); fflush(stdout); }
            dvmhStatShift += szd;

            CPYMEM(dvmhStatMetric->median, buffer+dvmhStatShift, szd);
			if (dvmhDebug) { printf("        median        : %.4f (%u)\n", dvmhStatMetric->median,dvmhStatShift); fflush(stdout); }
            dvmhStatShift += szd;

			CPYMEM(dvmhStatMetric->q3, buffer+dvmhStatShift, szd);
			if (dvmhDebug) { printf("        q3            : %.4f (%u)\n", dvmhStatMetric->q3,dvmhStatShift); fflush(stdout); }
            dvmhStatShift += szd;
            #endif

			if (dvmhDebug) { printf("        size          : %u\n", dvmhStatShift-t); fflush(stdout); }

			dvmhStatGpu->timeProductive += dvmhStatMetric->timeProductive > 0 ? dvmhStatMetric->timeProductive : 0.0;
			dvmhStatGpu->timeLost       += dvmhStatMetric->timeLost       > 0 ? dvmhStatMetric->timeLost       : 0.0;
		}

		if (dvmhDebug) { printf("     timeProductive: %.4f\n", dvmhStatGpu->timeProductive); fflush(stdout); }
		if (dvmhDebug) { printf("     timeLost      : %.4f\n", dvmhStatGpu->timeLost); fflush(stdout); }
		if (dvmhDebug) { printf("     size          : %d\n", dvmhStatShift-t2); fflush(stdout); }

		dvmhStatInterval->allGPUTimeProductive += dvmhStatGpu->timeProductive > 0 ? dvmhStatGpu->timeProductive : 0.0;
		dvmhStatInterval->allGPUTimeLost       += dvmhStatGpu->timeLost       > 0 ? dvmhStatGpu->timeLost       : 0.0;
	}

	if (dvmhDebug) { printf("allGPUTimeProductive: %.4f\n", dvmhStatInterval->allGPUTimeProductive); fflush(stdout); }
	if (dvmhDebug) { printf("allGPUTimeLost      : %.4f\n", dvmhStatInterval->allGPUTimeLost); fflush(stdout); }

	dvmhStatInterval->threadsUsed = false;
	if (dvmhDebug) { printf("Threads:\n"); fflush(stdout); }
	for(unsigned long i = 0; i < dvmhStatHeader->threadsAmount; ++i)
	{
		dvmh_stat_interval_thread* dvmhStatThread = &(dvmhStatInterval->threads[i]);
		CPYMEM(dvmhStatThread->user_time, buffer+dvmhStatShift, szd);
		if (dvmhDebug) { printf("    [%d] User time   : %.8f\n", i, dvmhStatThread->user_time); fflush(stdout); }
		dvmhStatShift += szd;
		CPYMEM(dvmhStatThread->system_time, buffer+dvmhStatShift, szd);
		if (dvmhDebug) { printf("    [%d] System time : %.8f\n", i, dvmhStatThread->system_time); fflush(stdout); }
		dvmhStatShift += szd;

		dvmhStatInterval->allThreadsUserTime   += dvmhStatThread->user_time   > 0 ? dvmhStatThread->user_time   : 0.0;
		dvmhStatInterval->allThreadsSystemTime += dvmhStatThread->system_time > 0 ? dvmhStatThread->system_time : 0.0;
	}
	if (dvmhDebug) { printf("allThreadsUserTime  : %.4f\n", dvmhStatInterval->allThreadsUserTime); fflush(stdout); }
	if (dvmhDebug) { printf("allThreadsSystemTime: %.4f\n", dvmhStatInterval->allThreadsSystemTime); fflush(stdout); }

	if(dvmhStatInterval->allThreadsUserTime > 0 || dvmhStatInterval->allThreadsSystemTime > 0)
		dvmhStatInterval->threadsUsed = true;

	return dvmhStatInterval;
}

//----------------------------------------
//return result of constructor execution
BOOL CTreeInter::Valid()
{
	return(valid);
}
//-------------------------------------------
// error message
void CTreeInter::TextErr(char *p)
{
	strcpy(p,texterr);
}

//-------------------------------------------------
//set current interval at the first interval
void CTreeInter::BeginInter(void)
{
	for (unsigned long i=0;i<qinter;i++) {
		pt[i].sign=0;
	}
	curninter=1;
	return;
}
//--------------------------------------------------
//read identifier information of current interval
void CTreeInter::NextInter(ident **id)
{
	*id=NULL;
	for (unsigned long i=curninter;i<=qinter;i++) {
		if (pt[i-1].sign==0) {
			pt[i-1].sign=1;
			curninter=i;
			CInter *p=pt[i-1].pint;
			p->ReadIdent(id);
			return;
		}
	}
	return;

}
//------------------------------------------------
// return pointer to interval with the same identifier information
// set current interval
CInter *CTreeInter::FindInter(ident *id)
//id - identifier information
{
	unsigned long n;
	ident *idcur;
	pt[curninter-1].pint->ReadIdent(&idcur);
	if (id==idcur) return(pt[curninter-1].pint); //the same processor
	if (id->nlev==idcur->nlev) { // the same level
		n=pt[curninter-1].up;
		if (n>0) n=pt[n-1].down;
		else n=curninter;// first interval
		while(n>0) {
			if (pt[n-1].sign==0 && pt[n-1].pint->CompIdent(id)==1) {
				pt[n-1].sign=1;
				curninter=n;
				return(pt[n-1].pint);
			}
			n=pt[n-1].next;
		}
		return(NULL);
	}
	// need level > current level
	n=curninter;
	if (id->nlev>idcur->nlev) {
		// find need down level
		while (id->nlev>idcur->nlev) {
			n=pt[n-1].down;
			if (n==0) return(NULL);
			pt[n-1].pint->ReadIdent(&idcur);
		}
		// find need interval on finded level
		while(n>0) {
			if (pt[n-1].sign==0 && pt[n-1].pint->CompIdent(id)==1) {
				pt[n-1].sign=1;
				curninter=n;
				return(pt[n-1].pint);
			}
			n=pt[n-1].next;
		}
		return(NULL);
	} else {
		// find need up level
		while (id->nlev<idcur->nlev) {
			n=pt[n-1].up;
			if (n==0) return(NULL);
			pt[n-1].pint->ReadIdent(&idcur);
		}
		unsigned long n1=n;
		n=pt[n-1].up;
		if (n>0) n=pt[n-1].down;else n=n1;
		while(n>0) {
			if (pt[n-1].sign==0 && pt[n-1].pint->CompIdent(id)==1) {
				pt[n-1].sign=1;
				curninter=n;
				return(pt[n-1].pint);
			}
			n=pt[n-1].next;
		}
	}
	return(NULL);
}
//--------------------------------------------------
//sum time characteristics
void CTreeInter::SumLevel(void)
{
	for (short i=maxnlev;i>0;i--) {
		for (unsigned long j=0;j<qinter;j++) {
			ident *id;
			pt[j].pint->ReadIdent(&id);
			if (id->nlev==i) {
				// psum - up level
				unsigned long up=pt[j].up;
				CInter *psum=pt[up-1].pint;
				pt[j].pint->SumInter(psum);
			}
		}
	}
	pt[0].pint->SumInter(NULL);
}
//---------------------------------------------------
//processor time
void CTreeInter::ReadProcTime(double &time)
{
	time=proctime;
}
//---------------------------------------------------
//processor name
void CTreeInter::ReadProcName(char **name)
{
	*name=pprocname;
}
//--------------------------------------------------
// deallocate memory for tree interval
CTreeInter::~CTreeInter()
{
	if (pprocname!=NULL) delete []pprocname;
	if (sign_buffer!=NULL) delete []sign_buffer;
	if (pt==NULL) return;
	for (unsigned long i=0;i<qinter;i++) {
		if (pt[i].pint!=NULL) pt[i].pint->~CInter();
		pt[i].pint=NULL;
	}
	delete []pt;
}