399 lines
9.6 KiB
C++
399 lines
9.6 KiB
C++
#include <assert.h>
|
|
|
|
#include "Vm.h"
|
|
|
|
using namespace std;
|
|
|
|
extern ofstream prot;
|
|
|
|
extern VM * rootVM = NULL; // pointer to root VM
|
|
extern VM * currentVM = NULL; // pointer to current VM
|
|
|
|
//grig
|
|
|
|
extern long_vect MinSizesOfAM; // äëÿ àâòîìàòè÷åñêîãî ïîèñêà
|
|
//\grig
|
|
|
|
//---------------------------------------------------------------------------------
|
|
//
|
|
// Constructor for root VM
|
|
//
|
|
//---------------------------------------------------------------------------------
|
|
VM::VM(const std::vector<long>& ASizeArray, mach_Type AMType, int AnumChanels,
|
|
double Ascale, double ATStart, double ATByte, double AProcPower,std::vector<double> & AvProcPower) :
|
|
Space(ASizeArray),
|
|
parent(NULL),
|
|
MType(AMType),
|
|
numChanels(AnumChanels),
|
|
scale(Ascale),
|
|
TStart(ATStart),
|
|
TByte(ATByte),
|
|
ProcPower(AProcPower),
|
|
ProcCount(procCount())
|
|
{
|
|
int i,j,l;
|
|
int rank = SizeArray.size();
|
|
|
|
/// for(i=0;i<ASizeArray.size();i++)
|
|
// {
|
|
// printf("%d ",ASizeArray[i]);
|
|
// }
|
|
// printf("\n");
|
|
|
|
// printf("rank=%d\n",this->Rank());
|
|
|
|
// weight
|
|
int k = 0;
|
|
for (i = 0; i < rank; i++)
|
|
k += SizeArray[i];
|
|
weight = vector<double>(k, 1.0);
|
|
|
|
//grig
|
|
vWeights = vector<double>(k,1.0); // init weights array
|
|
vProcPower.resize(0);
|
|
for(i=0;i<ProcCount;i++)
|
|
{
|
|
vProcPower.push_back(AvProcPower[i]);
|
|
}
|
|
//\grig
|
|
|
|
// initialize mapping;
|
|
mapping = vector<int>(ProcCount);
|
|
|
|
// prot << "ProcCount = " << ProcCount << " rank = " << rank << endl;
|
|
// set mapping
|
|
// root VM : mapping 1:1
|
|
switch (rank) {
|
|
case 1:
|
|
for (i = 0; i < SizeArray[0]; i++)
|
|
mapping[i] = i;
|
|
break;
|
|
case 2:
|
|
for (j = 0; j < SizeArray[0]; j++)
|
|
for (i = 0; i < SizeArray[1]; i++) {
|
|
// cout << " i = " << i << " j = " << j << endl;
|
|
mapping[i + MultArray[0] * j] = i + MultArray[0] * j;
|
|
}
|
|
break;
|
|
case 3:
|
|
for (k = 0; k < SizeArray[0]; k++)
|
|
for (j = 0; j < SizeArray[1]; j++)
|
|
for (i = 0; i < SizeArray[2]; i++)
|
|
mapping[i + MultArray[1] * j + MultArray[0] * k] =
|
|
i + MultArray[1] * j + MultArray[0] * k;
|
|
break;
|
|
case 4:
|
|
for (l = 0; l < SizeArray[0]; l++)
|
|
for (k = 0; k < SizeArray[1]; k++)
|
|
for (j = 0; j < SizeArray[2]; j++)
|
|
for (i = 0; i < SizeArray[3]; i++)
|
|
mapping[i + MultArray[2] * j + MultArray[1] * k + MultArray[0] * l] =
|
|
i + MultArray[2] * j + MultArray[1] * k + MultArray[0] * l;
|
|
break;
|
|
default:
|
|
prot << "VM rank more then 4 (rank = " << rank << ')' << endl;
|
|
printf("VM rank more then 4 (rank = %d)\n", rank);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// for(i=0;i<ProcCount;i++)
|
|
// {
|
|
// printf("::TEST MAPPING : logical num=%d, it's mapped to %d processor of PS it's power is %f\n",i,map(i),getProcPower(i));
|
|
// }
|
|
|
|
//for(i=0;i<GetSize(i+1);i++)
|
|
// for(j=0;j<GetSize)
|
|
/* std::vector<long> sss;
|
|
sss.resize(2);
|
|
sss[0]=1;
|
|
sss[0]=2;
|
|
long rrr=GetLI(sss);
|
|
*/
|
|
}
|
|
|
|
|
|
VM::VM(const std::vector<long>& ASizeArray, mach_Type AMType, int AnumChanels,
|
|
double Ascale, double ATStart, double ATByte, std::vector<double>& AvProcPower) :
|
|
Space(ASizeArray),
|
|
parent(NULL),
|
|
MType(AMType),
|
|
numChanels(AnumChanels),
|
|
scale(Ascale),
|
|
TStart(ATStart),
|
|
TByte(ATByte),
|
|
ProcPower(1.0),
|
|
ProcCount(procCount())
|
|
{
|
|
int i,j,l;
|
|
int rank = SizeArray.size();
|
|
|
|
// for(i=0;i<ASizeArray.size();i++)
|
|
// {
|
|
// printf("%d ",ASizeArray[i]);
|
|
// }
|
|
// printf("\n");
|
|
|
|
// printf("rank=%d\n",this->Rank());
|
|
|
|
// weight
|
|
int k = 0;
|
|
for (i = 0; i < rank; i++)
|
|
k += SizeArray[i];
|
|
weight = vector<double>(k, 1.0);
|
|
|
|
//grig
|
|
vWeights = vector<double>(k,1.0); // init weights array
|
|
vProcPower.resize(0);
|
|
for(i=0;i<ProcCount;i++)
|
|
{
|
|
vProcPower.push_back(AvProcPower[i]);
|
|
}
|
|
//\grig
|
|
|
|
// initialize mapping;
|
|
mapping = vector<int>(ProcCount);
|
|
|
|
// prot << "ProcCount = " << ProcCount << " rank = " << rank << endl;
|
|
// set mapping
|
|
// root VM : mapping 1:1
|
|
switch (rank) {
|
|
case 1:
|
|
for (i = 0; i < SizeArray[0]; i++)
|
|
mapping[i] = i;
|
|
break;
|
|
case 2:
|
|
for (j = 0; j < SizeArray[0]; j++)
|
|
for (i = 0; i < SizeArray[1]; i++) {
|
|
// cout << " i = " << i << " j = " << j << endl;
|
|
mapping[i + MultArray[0] * j] = i + MultArray[0] * j;
|
|
}
|
|
break;
|
|
case 3:
|
|
for (k = 0; k < SizeArray[0]; k++)
|
|
for (j = 0; j < SizeArray[1]; j++)
|
|
for (i = 0; i < SizeArray[2]; i++)
|
|
mapping[i + MultArray[1] * j + MultArray[0] * k] =
|
|
i + MultArray[1] * j + MultArray[0] * k;
|
|
break;
|
|
case 4:
|
|
for (l = 0; l < SizeArray[0]; l++)
|
|
for (k = 0; k < SizeArray[1]; k++)
|
|
for (j = 0; j < SizeArray[2]; j++)
|
|
for (i = 0; i < SizeArray[3]; i++)
|
|
mapping[i + MultArray[2] * j + MultArray[1] * k + MultArray[0] * l] =
|
|
i + MultArray[2] * j + MultArray[1] * k + MultArray[0] * l;
|
|
break;
|
|
default:
|
|
prot << "VM rank more then 4 (rank = " << rank << ')' << endl;
|
|
printf("VM rank more then 4 (rank = %d)\n", rank);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
// for(i=0;i<ProcCount;i++)
|
|
// {
|
|
// printf("::TEST MAPPING : logical num=%d, it's mapped to %d processor of PS it's power is %f\n",i,map(i),getProcPower(i));
|
|
// }
|
|
//
|
|
//for(i=0;i<GetSize(i+1);i++)
|
|
// for(j=0;j<GetSize)
|
|
/* std::vector<long> sss;
|
|
sss.resize(2);
|
|
sss[0]=1;
|
|
sss[0]=2;
|
|
long rrr=GetLI(sss);
|
|
*/
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------
|
|
//
|
|
// Constructor for child VM (crtps_)
|
|
//
|
|
//---------------------------------------------------------------------------------
|
|
|
|
VM::VM(const std::vector<long>& lb, const std::vector<long>& ASizeArray, const VM* Aparent) :
|
|
Space(ASizeArray),
|
|
parent(Aparent),
|
|
MType(parent->MType),
|
|
numChanels(parent->numChanels),
|
|
scale(parent->scale),
|
|
TStart(parent->TStart),
|
|
TByte(parent->TByte),
|
|
ProcPower(parent->ProcPower),
|
|
ProcCount(procCount())
|
|
{
|
|
int i,j,l;
|
|
int rank = SizeArray.size();
|
|
|
|
// weight
|
|
int k = 0;
|
|
for (i = 0; i < rank; i++)
|
|
k += SizeArray[i];
|
|
weight = vector<double>(k, 1.0);
|
|
|
|
//grig
|
|
vWeights=vector<double>(k,1.0);
|
|
//\grig
|
|
|
|
// initialize mapping;
|
|
mapping = vector<int>(ProcCount);
|
|
|
|
// set mapping
|
|
// child VM
|
|
switch (rank) {
|
|
case 1:
|
|
for (i = 0; i < SizeArray[0]; i++)
|
|
mapping[i] = parent->mapping[i + lb[0]];
|
|
break;
|
|
case 2:
|
|
for (j = 0; j < SizeArray[0]; j++)
|
|
for (i = 0; i < SizeArray[1]; i++)
|
|
mapping[i + MultArray[0] * j] =
|
|
parent->mapping[ i + lb[1] +
|
|
(j + lb[0]) * parent->MultArray[0]];
|
|
break;
|
|
case 3:
|
|
for (k = 0; k < SizeArray[0]; k++)
|
|
for (j = 0; j < SizeArray[1]; j++)
|
|
for (i = 0; i < SizeArray[2]; i++)
|
|
mapping[i + MultArray[1] * j + MultArray[0] * k] =
|
|
parent->mapping[ i + lb[2] +
|
|
(j + lb[1]) * parent->MultArray[1] +
|
|
(k + lb[0]) * parent->MultArray[0]];
|
|
break;
|
|
case 4:
|
|
for (l = 0; l < SizeArray[0]; l++)
|
|
for (k = 0; k < SizeArray[1]; k++)
|
|
for (j = 0; j < SizeArray[2]; j++)
|
|
for (i = 0; i < SizeArray[3]; i++)
|
|
mapping[i + MultArray[2] * j + MultArray[1] * k + MultArray[0] * l] =
|
|
parent->mapping[ i + lb[3] +
|
|
(j + lb[2]) * parent->MultArray[2] +
|
|
(k + lb[1]) * parent->MultArray[1] +
|
|
(l + lb[0]) * parent->MultArray[0]];
|
|
|
|
break;
|
|
default:
|
|
prot << "VM rank more then 4 (rank = " << rank << ')' << endl;
|
|
printf("VM rank more then 4 (rank = %d)\n", rank);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
//grig
|
|
vProcPower.resize(0);
|
|
|
|
for(i=0;i<ProcCount;i++)
|
|
this->vProcPower.push_back(1.0);
|
|
|
|
for(i=0;i<ProcCount;i++)
|
|
this->vProcPower[i]=Aparent->vProcPower[i];
|
|
//\grig
|
|
|
|
|
|
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
//
|
|
// Constructor for child VM (psview_)
|
|
//
|
|
//---------------------------------------------------------------------------------
|
|
|
|
VM::VM(const std::vector<long>& ASizeArray, const VM* Aparent) :
|
|
Space(ASizeArray),
|
|
parent(Aparent),
|
|
MType(parent->MType),
|
|
numChanels(parent->numChanels),
|
|
scale(parent->scale),
|
|
TStart(parent->TStart),
|
|
TByte(parent->TByte),
|
|
ProcPower(parent->ProcPower),
|
|
ProcCount(procCount()),
|
|
mapping(parent->mapping)
|
|
{
|
|
int k,
|
|
i;
|
|
|
|
|
|
//grig
|
|
vProcPower.resize(0);
|
|
for(i=0;i<Aparent->ProcCount;i++)
|
|
this->vProcPower.push_back(1.0);
|
|
for(i=0;i<ProcCount;i++)
|
|
this->vProcPower[i]=Aparent->vProcPower[i];
|
|
//\grig
|
|
|
|
// weight
|
|
for (k = 0, i = 0; i < SizeArray.size(); i++)
|
|
k += SizeArray[i];
|
|
weight = vector<double>(k, 1.0);
|
|
|
|
//grig
|
|
vWeights=vector<double>(k,1.0);
|
|
//\grig
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------
|
|
//
|
|
// Set weights for VM
|
|
//
|
|
//---------------------------------------------------------------------------------
|
|
void VM::setWeight(const std::vector<double>& Aweight)
|
|
{
|
|
assert(Aweight.size() == weight.size());
|
|
weight = Aweight;
|
|
|
|
//grig
|
|
vWeights=Aweight;
|
|
//\grig
|
|
}
|
|
//---------------------------------------------------------------------------------
|
|
//
|
|
// calculates number of processors in VM
|
|
//
|
|
//---------------------------------------------------------------------------------
|
|
int VM::procCount()
|
|
{
|
|
ProcCount = 1;
|
|
for (int i = 0; i < SizeArray.size(); i++) {
|
|
ProcCount *= SizeArray[i];
|
|
}
|
|
return ProcCount;
|
|
}
|
|
|
|
VM::~VM()
|
|
{
|
|
if(this->parent!=NULL)
|
|
parent=NULL;
|
|
mapping.resize(0);
|
|
weight.resize(0);
|
|
|
|
vProcPower.resize(0);
|
|
vWeights.resize(0);
|
|
}
|
|
|
|
|
|
|
|
|
|
#ifdef P_DEBUG
|
|
|
|
ostream& operator << (ostream& os, const VM& vm)
|
|
{
|
|
int i;
|
|
unsigned int rank = vm.mapping.size();
|
|
|
|
os << (Space) vm;
|
|
|
|
os << " Map =";
|
|
for (i = 0; i < rank; i++ )
|
|
os << ' ' << vm.mapping[i];
|
|
os << ' ';
|
|
return os;
|
|
}
|
|
|
|
#endif
|
|
|