1243 lines
44 KiB
C++
1243 lines
44 KiB
C++
|
#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 synchronization times from file
|
|||
|
|
// name - file name
|
|||
|
|
CStatRead::CStatRead(const char *statFilePath, int iIM, int jIM, short sore)
|
|||
|
|
{
|
|||
|
|
gzFile statFile = NULL;
|
|||
|
|
|
|||
|
|
curnproc = 0;
|
|||
|
|
curntime = 0;
|
|||
|
|
nf = 0;
|
|||
|
|
rank = 0;
|
|||
|
|
maxnlevel = 0;
|
|||
|
|
pch_vms = NULL;
|
|||
|
|
smallbuff = 0;
|
|||
|
|
valid_synchro = false;
|
|||
|
|
|
|||
|
|
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;
|
|||
|
|
|
|||
|
|
statFile = gzopen(statFilePath, "rb");
|
|||
|
|
if (statFile == NULL) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't open file %s \n", statFilePath);
|
|||
|
|
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(statFilePath, ".gz+") != NULL) {
|
|||
|
|
gzplus = 1;
|
|||
|
|
int k;
|
|||
|
|
for (k = 0; ; k++) { // number of compressed bytes
|
|||
|
|
if (gzread(statFile, &(lbufplusch[k]), 1) != 1) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s \n", statFilePath);
|
|||
|
|
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(statFile, &(nprocch[k]), 1) != 1) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s \n", statFilePath);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (nprocch[k] == 0) break;
|
|||
|
|
}
|
|||
|
|
for (k = 0; ; k++) { // number of compressed bytes
|
|||
|
|
if (gzread(statFile, &(lbufplusch[k]), 1) != 1) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s \n", statFilePath);
|
|||
|
|
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(statFile, pbufcompr, lbufcompr);
|
|||
|
|
if (s != (int) lbufcompr) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s l=%ld\n", statFilePath, 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(statFile);
|
|||
|
|
psz = (unsigned char *) (&(sz[0]));
|
|||
|
|
// read const information about size of variables and reverse
|
|||
|
|
s = gzread(statFile, &sz, sizeof(sz));
|
|||
|
|
if (s != (int) sizeof(sz)) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s addr=%ld size=%d\n",
|
|||
|
|
statFilePath, 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", statFilePath);
|
|||
|
|
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(statFile);
|
|||
|
|
s = gzread(statFile, pch_vms, lvms);
|
|||
|
|
if (s != lvms) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s addr=%ld size=%d\n",
|
|||
|
|
statFilePath, 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(statFile);
|
|||
|
|
s = gzread(statFile, pch_vmssize, szl * rank);
|
|||
|
|
if (s != szl * rank) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s addr=%ld size=%d\n",
|
|||
|
|
statFilePath, 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(statFile);
|
|||
|
|
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(statFile, pvers, lvers);
|
|||
|
|
if (s != lvers) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s addr=%ld size=%d\n",
|
|||
|
|
statFilePath, l, lvers);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
pbuffer = pbuffer + lvms_add + lvers;
|
|||
|
|
|
|||
|
|
// -- dvmh
|
|||
|
|
unsigned int dvmhGpuIndex, dvmhStringPos;
|
|||
|
|
unsigned char *dvmhStatBuffer = (unsigned char *) (pbufuncompr + lvms_add + lvers);
|
|||
|
|
dvmh_stat_header *dvmhStatHeader = new dvmh_stat_header();
|
|||
|
|
dvmh_stat_header_gpu_info *dvmhStatGpuInfo;
|
|||
|
|
|
|||
|
|
if (dvmhDebug) { printf("Proc #%d\n",i); fflush(stdout); }
|
|||
|
|
|
|||
|
|
if (!dvmhStatHeader) throw("Out of memory\n");
|
|||
|
|
|
|||
|
|
if (dvmhDebug) { printf(" Allocated memory for DVMH statistics header.\n"); fflush(stdout); }
|
|||
|
|
|
|||
|
|
// Читаем информацию о размерах структур
|
|||
|
|
CPYMEM(dvmhStatHeader->sizeHeader, dvmhStatBuffer, szl);
|
|||
|
|
dvmhStatBuffer += szl;
|
|||
|
|
CPYMEM(dvmhStatHeader->sizeIntervalConstPart, dvmhStatBuffer, szl);
|
|||
|
|
dvmhStatBuffer += szl;
|
|||
|
|
CPYMEM(dvmhStatHeader->threadsAmount, dvmhStatBuffer, szl);
|
|||
|
|
dvmhStatBuffer += szl;
|
|||
|
|
|
|||
|
|
if (dvmhDebug) {
|
|||
|
|
printf(" dvmhHeaderSize : %lu\n", dvmhStatHeader->sizeHeader);
|
|||
|
|
printf(" dvmhIntervalSizeConstPart : %lu\n", dvmhStatHeader->sizeIntervalConstPart);
|
|||
|
|
printf(" threadsAmount : %lu\n", dvmhStatHeader->threadsAmount);
|
|||
|
|
fflush(stdout);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// Читаем информацию о GPU процессора
|
|||
|
|
for (dvmhGpuIndex = 0; dvmhGpuIndex < DVMH_STAT_MAX_GPU_CNT; ++dvmhGpuIndex) {
|
|||
|
|
dvmhStatGpuInfo = & dvmhStatHeader->gpu[dvmhGpuIndex];
|
|||
|
|
CPYMEM(dvmhStatGpuInfo->id, dvmhStatBuffer, szl);
|
|||
|
|
dvmhStatBuffer += szl;
|
|||
|
|
for (dvmhStringPos = 0; dvmhStringPos <= DVMH_STAT_SIZE_STR; ++dvmhStringPos) {
|
|||
|
|
CPYMEM(dvmhStatGpuInfo->name[dvmhStringPos], dvmhStatBuffer, 1);
|
|||
|
|
dvmhStatBuffer++;
|
|||
|
|
}
|
|||
|
|
if (dvmhDebug) {
|
|||
|
|
printf(" GPU #%d\n",dvmhGpuIndex);
|
|||
|
|
printf(" Id : %d\n", dvmhStatGpuInfo->id);
|
|||
|
|
printf(" Name: %s\n", dvmhStatGpuInfo->name);
|
|||
|
|
fflush(stdout);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if (dvmhDebug) { printf(" GPU info loaded.\n"); fflush(stdout); }
|
|||
|
|
|
|||
|
|
// Устанавливаем начальный указатель на интервалы @todo
|
|||
|
|
pbuffer += dvmhStatHeader->sizeHeader;
|
|||
|
|
// --
|
|||
|
|
|
|||
|
|
|
|||
|
|
unsigned char *pinterinbuff;
|
|||
|
|
if (gzplus == 1) pinterinbuff = pbufuncompr + lvms_add + lvers + dvmhStatHeader->sizeHeader; //-- dvmh
|
|||
|
|
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(statFile, linter, pbuffer, i, qfrag, maxn,
|
|||
|
|
pprocname, proct, iIM, jIM, sore, pinterinbuff, dvmhStatHeader); // --dvmh
|
|||
|
|
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(statFile, lbuf - lsynchro - linter - lvms_add - lvers, SEEK_CUR) == -1) {
|
|||
|
|
sprintf(texterr, "Can't read from file %s addr=%ld size=%ld\n",
|
|||
|
|
statFilePath, l, lbuf - lsynchro - linter - lvms_add - lvers);
|
|||
|
|
valid = FALSE;
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
if (lsynchro > 0) {
|
|||
|
|
l = gztell(statFile);
|
|||
|
|
// create array of synchronization times
|
|||
|
|
try {
|
|||
|
|
pclsyn[i] = new CSynchro(statFile, 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(statFile, 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(statFile, &(lbufplusch[k]), 1) != 1) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s \n", statFilePath);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
if (lbufplusch[k] == 0) break;
|
|||
|
|
}
|
|||
|
|
lbufcompr = atol(lbufplusch);
|
|||
|
|
pbufcompr = new unsigned char[lbufcompr];
|
|||
|
|
if (pbufcompr == NULL) throw("Out of memory\n");
|
|||
|
|
s = gzread(statFile, pbufcompr, lbufcompr);
|
|||
|
|
if (s != (int) lbufcompr) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s l=%ld\n", statFilePath, 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(statFile, &sz, sizeof(sz));
|
|||
|
|
if (s != sizeof(sz)) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s addr=%ld size=%d\n",
|
|||
|
|
statFilePath, l, (int) sizeof(sz));
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
s = gzread(statFile, pch_vms, lvms);
|
|||
|
|
if (s != lvms) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s addr=%ld size=%d\n",
|
|||
|
|
statFilePath, l, lvms);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
CPYMEM(rank, pch_vms + MAKESHORT(pb_vms, rank, rank), szsh);
|
|||
|
|
if (gzplus == 1) pch_vms = pbufuncompr + sizeof(sz);
|
|||
|
|
else {
|
|||
|
|
l = gztell(statFile);
|
|||
|
|
s = gzread(statFile, pch_vmssize, szl * rank);
|
|||
|
|
if (s != szl * rank) {
|
|||
|
|
valid = FALSE;
|
|||
|
|
sprintf(texterr, "Can't read from file %s addr=%ld size=%d\n",
|
|||
|
|
statFilePath, l, szl * rank);
|
|||
|
|
return;
|
|||
|
|
}
|
|||
|
|
l = gztell(statFile);
|
|||
|
|
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(statFile);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//--------------------------------------------------
|
|||
|
|
// 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
|
|||
|
|
// return number of intervals
|
|||
|
|
unsigned long CStatRead::BeginTreeWalk(void)
|
|||
|
|
{
|
|||
|
|
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
|
|||
|
|
// return number of intervals
|
|||
|
|
unsigned long CStatRead::TreeWalk(void)
|
|||
|
|
{
|
|||
|
|
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
|
|||
|
|
// return 0 - OK
|
|||
|
|
BOOL CStatRead::Synchro(void)
|
|||
|
|
{
|
|||
|
|
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
|
|||
|
|
void CStatRead::ReadIdent(ident *idp) {
|
|||
|
|
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++;
|
|||
|
|
idp->t = id->t;
|
|||
|
|
idp->nline_end = id->nline_end;
|
|||
|
|
idp->proc = id->proc;
|
|||
|
|
idp->nlev = id->nlev;
|
|||
|
|
idp->nline = id->nline;
|
|||
|
|
idp->expr = id->expr;
|
|||
|
|
idp->nenter = nent;
|
|||
|
|
if (id->pname == NULL) {
|
|||
|
|
idp->pname = NULL;
|
|||
|
|
}
|
|||
|
|
else {
|
|||
|
|
idp->pname = new char[strlen(id->pname) + 1];
|
|||
|
|
strcpy(idp->pname, id->pname);
|
|||
|
|
}
|
|||
|
|
curntime = 0;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
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()
|
|||
|
|
//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.
|
|||
|
|
BOOL CStatRead::ReadProc(typeprint t, unsigned long *pnumb, int qnumb, short fmt, double sum, char *str)
|
|||
|
|
{
|
|||
|
|
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);
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void CStatRead::ReadProcS(ProcTimes *pt)
|
|||
|
|
{
|
|||
|
|
//printf("readprocs\n");
|
|||
|
|
for (unsigned long i = 0; i < proccount; i++) {
|
|||
|
|
// read time characteristic
|
|||
|
|
double time;
|
|||
|
|
//printf("readtime\n");
|
|||
|
|
pic[i]->ReadTime((typetime)(LOST), time);
|
|||
|
|
pt[i].lost_time = time;
|
|||
|
|
//printf("readtime\n");
|
|||
|
|
pic[i]->ReadTime((typetime)(INSUFUSR), time);
|
|||
|
|
pt[i].insuf_user = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(INSUF), time);
|
|||
|
|
pt[i].insuf_sys = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(IDLE), time);
|
|||
|
|
pt[i].idle = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(SUMCOM), time);
|
|||
|
|
pt[i].comm = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(SUMRCOM), time);
|
|||
|
|
pt[i].real_comm = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(SUMSYN), time);
|
|||
|
|
pt[i].synch = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(SUMVAR), time);
|
|||
|
|
pt[i].time_var = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(IMB), time);
|
|||
|
|
pt[i].load_imb = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(EXEC), time);
|
|||
|
|
pt[i].exec_time = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(CPUUSR), time);
|
|||
|
|
pt[i].prod_cpu = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(CPU), time);
|
|||
|
|
pt[i].prod_sys = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(IOTIME), time);
|
|||
|
|
pt[i].prod_io = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(START), time);
|
|||
|
|
pt[i].overlap = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(DVMH_THREADS_USER_TIME), time);
|
|||
|
|
pt[i].thr_user_time = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(DVMH_THREADS_SYSTEM_TIME), time);
|
|||
|
|
pt[i].thr_sys_time = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(DVMH_GPU_TIME_PRODUCTIVE), time);
|
|||
|
|
pt[i].gpu_time_prod = time;
|
|||
|
|
pic[i]->ReadTime((typetime)(DVMH_GPU_TIME_LOST), time);
|
|||
|
|
pt[i].gpu_time_lost = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(IO), time);
|
|||
|
|
pt[i].col_op[IO].comm = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RD), time);
|
|||
|
|
pt[i].col_op[RD].comm = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(SH), time);
|
|||
|
|
pt[i].col_op[SH].comm = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RA), time);
|
|||
|
|
pt[i].col_op[RA].comm = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(IO), time);
|
|||
|
|
pt[i].col_op[IO].real_comm = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RD), time);
|
|||
|
|
pt[i].col_op[RD].real_comm = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(SH), time);
|
|||
|
|
pt[i].col_op[SH].real_comm = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RA), time);
|
|||
|
|
pt[i].col_op[RA].real_comm = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(IO), time);
|
|||
|
|
pt[i].col_op[IO].synch = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RD), time);
|
|||
|
|
pt[i].col_op[RD].synch = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(SH), time);
|
|||
|
|
pt[i].col_op[SH].synch = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RA), time);
|
|||
|
|
pt[i].col_op[RA].synch = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(IO), time);
|
|||
|
|
pt[i].col_op[IO].time_var = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RD), time);
|
|||
|
|
pt[i].col_op[RD].time_var = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(SH), time);
|
|||
|
|
pt[i].col_op[SH].time_var = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RA), time);
|
|||
|
|
pt[i].col_op[RA].time_var = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(IO), time);
|
|||
|
|
pt[i].col_op[IO].overlap = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RD), time);
|
|||
|
|
pt[i].col_op[RD].overlap = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(SH), time);
|
|||
|
|
pt[i].col_op[SH].overlap = time;
|
|||
|
|
pic[i]->ReadTime(COM, (typecom)(RA), time);
|
|||
|
|
pt[i].col_op[RA].overlap = time;
|
|||
|
|
//printf("readtime\n");
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
//--------------------------------------------------------
|
|||
|
|
// calculate min,max,sum time characteristics
|
|||
|
|
// 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.
|
|||
|
|
void CStatRead::MinMaxSum(typeprint t, double *min, unsigned long *nprocmin,
|
|||
|
|
double *max, unsigned long *nprocmax,
|
|||
|
|
double *sum)
|
|||
|
|
{
|
|||
|
|
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;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
// -- dvmh
|
|||
|
|
|
|||
|
|
dvmh_stat_interval * CStatRead::getDvmhStatIntervalByProcess(unsigned long nProc) {
|
|||
|
|
return pic[nProc - 1]->dvmhStatInterval;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
dvmh_stat_header_gpu_info * CStatRead::getDvmhStatGpuInfoByProcess(unsigned long nProc, int nGpu) {
|
|||
|
|
return & pclfrag[nProc - 1]->dvmhStatHeader->gpu[nGpu];
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
unsigned long CStatRead::getThreadsAmountByProcess(unsigned long nProc) {
|
|||
|
|
return pclfrag[nProc - 1]->dvmhStatHeader->threadsAmount;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
void CStatRead::getMaxsAndMins(double* maxs, double* mins, double* meds, unsigned long* n, unsigned long nProc)
|
|||
|
|
{
|
|||
|
|
unsigned long threadsAmount = getThreadsAmountByProcess(nProc);
|
|||
|
|
dvmh_stat_interval* dvmhStatInterval = pic[nProc - 1]->dvmhStatInterval;
|
|||
|
|
|
|||
|
|
meds[0] = meds[1] = 0;
|
|||
|
|
maxs[0] = mins[0] = dvmhStatInterval->threads[0].user_time;
|
|||
|
|
maxs[1] = mins[1] = dvmhStatInterval->threads[0].system_time;
|
|||
|
|
n[0] = n[1] = n[2] = n[3] = 1;
|
|||
|
|
for(unsigned long i=0;i<threadsAmount;++i)
|
|||
|
|
{
|
|||
|
|
double user_time = dvmhStatInterval->threads[i].user_time;
|
|||
|
|
double system_time = dvmhStatInterval->threads[i].system_time;
|
|||
|
|
if(user_time > maxs[0])
|
|||
|
|
{
|
|||
|
|
maxs[0] = user_time;
|
|||
|
|
n[0] = i+1;
|
|||
|
|
}
|
|||
|
|
else if(user_time < mins[0])
|
|||
|
|
{
|
|||
|
|
mins[0] = user_time;
|
|||
|
|
n[1] = i+1;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
if(system_time > maxs[1])
|
|||
|
|
{
|
|||
|
|
maxs[1] = system_time;
|
|||
|
|
n[2] = i+1;
|
|||
|
|
}
|
|||
|
|
else if(system_time < mins[1])
|
|||
|
|
{
|
|||
|
|
mins[1] = system_time;
|
|||
|
|
n[3] = i+1;
|
|||
|
|
}
|
|||
|
|
meds[0] += user_time / threadsAmount;
|
|||
|
|
meds[1] += system_time / threadsAmount;
|
|||
|
|
}
|
|||
|
|
}
|