822 lines
24 KiB
C++
822 lines
24 KiB
C++
#include <assert.h>
|
|
#include "DArray.h"
|
|
//#include "ModelStructs.h"
|
|
#include <iostream>
|
|
using namespace std;
|
|
|
|
extern ofstream prot;
|
|
|
|
extern bool SynchCopy; //====//
|
|
DArray::DArray(const vector<long>& ASizeArray, const vector<long>& ALowShdWidthArray,
|
|
const vector<long>& AHiShdWidthArray, int ATypeSize) :
|
|
|
|
Space(ASizeArray),
|
|
LowShdWidthArray(ALowShdWidthArray),
|
|
HiShdWidthArray(AHiShdWidthArray),
|
|
TypeSize(abs(ATypeSize)), //====//=*** - is needed in case of negative TypeSize - when it is fixed in trace file, then this 'abs' no need here
|
|
AM_Dis(0),
|
|
Repl(0),
|
|
AlignRule(vector<AlignAxis>(0))
|
|
{
|
|
}
|
|
|
|
DArray::~DArray()
|
|
{
|
|
}
|
|
|
|
void DArray::PrepareAlign(long& TempRank, const vector<long>& AAxisArray,
|
|
const vector<long>& ACoeffArray, const vector<long>& AConstArray,
|
|
vector<AlignAxis>& IniRule)
|
|
{
|
|
long ArrRank, ARSize;
|
|
int i,j;
|
|
|
|
ArrRank = Rank();
|
|
ARSize = ArrRank + TempRank;
|
|
|
|
IniRule.reserve(ARSize);
|
|
|
|
// Ïðåäâàðèòåëüíàÿ èíèöèàëèçàöèÿ
|
|
for (i = 0; i < ArrRank; i++)
|
|
IniRule.push_back(AlignAxis(align_COLLAPSE, i+1, 0));
|
|
|
|
/* Lu deb
|
|
for(i=0;i<IniRule.size();i++)
|
|
printf("ini %d %d %d %d ",IniRule[i].A, IniRule[i].B, IniRule[i].Axis, IniRule[i].TAxis);
|
|
printf("\n");
|
|
*/
|
|
for (i = ArrRank; i < ARSize; i++)
|
|
IniRule.push_back(AlignAxis(align_NORMTAXIS, 0, i-ArrRank+1));
|
|
|
|
/* Lu deb
|
|
for(i=0;i<IniRule.size();i++)
|
|
printf("ini %d %d %d %d ",IniRule[i].A, IniRule[i].B, IniRule[i].Axis, IniRule[i].TAxis);
|
|
printf("\n");
|
|
*/
|
|
// Çàïîëíåíèå DistRule â ñîîòâåòñòâèè ñ ïàðàìåòðàìè
|
|
for (i = 0; i < TempRank; i++) {
|
|
if (i>=AAxisArray.size() || AAxisArray[i] < 0) // klinov add i>=AAxisArray.size()
|
|
IniRule[i+ArrRank] = AlignAxis(align_REPLICATE, 0, i+1);
|
|
else if (ACoeffArray[i] == 0 || AAxisArray[i] == 0)
|
|
// in new version last condition not require
|
|
IniRule[i+ArrRank] = AlignAxis(align_CONSTANT, 0, i+1, 0, AConstArray[i]);
|
|
else {
|
|
IniRule[i+ArrRank] = AlignAxis(align_NORMTAXIS, AAxisArray[i], i+1);
|
|
IniRule[AAxisArray[i]-1] = AlignAxis(align_NORMAL, AAxisArray[i], i+1, ACoeffArray[i], AConstArray[i]);
|
|
}
|
|
}
|
|
|
|
/* Lu deb
|
|
for(i=0;i<IniRule.size();i++)
|
|
printf("ini %d %d %d %d ",IniRule[i].A, IniRule[i].B, IniRule[i].Axis, IniRule[i].TAxis);
|
|
printf("\n");
|
|
*/
|
|
}
|
|
|
|
void DArray::AlnDA(AMView *APattern, const vector<long>& AAxisArray,
|
|
const vector<long>& ACoeffArray, const vector<long>& AConstArray)
|
|
{
|
|
long i;
|
|
int dir;
|
|
|
|
vector<AlignAxis> IniRule;
|
|
|
|
long TempRank = APattern->Rank();
|
|
|
|
AM_Dis = APattern;
|
|
APattern->AddDA(this);
|
|
|
|
// Îôîðìëåíèå ïðèçíàêà ïîëíîñòüþ ðàçìíîæåííîãî ìàññèâà
|
|
//for (i = 0; i < TempRank; i++)
|
|
// if (AAxisArray[i] != -1)
|
|
// break;
|
|
//if(i == TempRank)
|
|
// Repl = 1; // ðàçìíîæåíèå ïî âñåì èçìåðåíèÿì
|
|
//else
|
|
// Repl = 0;
|
|
|
|
// èíèöèàëèçàöèÿ AlignRule
|
|
PrepareAlign(TempRank, AAxisArray, ACoeffArray, AConstArray, IniRule);
|
|
AlignRule = IniRule;
|
|
|
|
// Îôîðìëåíèå ïðèçíàêà ïîëíîñòüþ ðàçìíîæåííîãî ìàññèâà
|
|
Repl = 1;
|
|
for (i = 0; i < TempRank; i++) {
|
|
switch (AlignRule[i + Rank()].Attr) {
|
|
case align_CONSTANT :
|
|
if (AM_Dis->DistRule[AlignRule[i + Rank()].TAxis - 1].Attr == map_BLOCK)
|
|
Repl = 0;
|
|
break;
|
|
case align_NORMTAXIS:
|
|
if (GetMapDim(AlignRule[i + Rank()].Axis, dir) > 0)
|
|
Repl = 0;
|
|
break;
|
|
}
|
|
|
|
if (!Repl)
|
|
break;
|
|
}
|
|
|
|
#ifdef _TIME_TRACE_
|
|
// Íå íóæíî
|
|
vector<AlignAxis>::iterator first = AlignRule.begin(), last = AlignRule.end();
|
|
while(first != last) {
|
|
prot << endl << first->Attr << " " << first->Axis << " " << first->TAxis << " " << first->A << " " << first->B << " " << first->Bound << endl;
|
|
++first;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void DArray::AlnDA(DArray *APattern, const vector<long>& AAxisArray,
|
|
const vector<long>& ACoeffArray, const vector<long>& AConstArray)
|
|
{
|
|
int i;
|
|
|
|
if (!APattern->IsAlign()) {
|
|
prot << "Wrong call AlnDA" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
long TempRank,
|
|
ArrRank,
|
|
ARSize;
|
|
AMView * TempAMV;
|
|
vector<AlignAxis> TAlign,
|
|
IniRule;
|
|
AlignAxis aAl,
|
|
tAl;
|
|
|
|
TAlign = APattern->AlignRule;
|
|
TempRank = APattern->Rank();
|
|
TempAMV = APattern->AM_Dis;
|
|
|
|
AM_Dis = TempAMV;
|
|
TempAMV->AddDA(this);
|
|
|
|
// Îôîðìëåíèå ïðèçíàêà ïîëíîñòüþ ðàçìíîæåííîãî ìàññèâà
|
|
Repl = APattern->Repl; // íàñëåäîâàíèå ó øàáëîíà
|
|
|
|
// íà÷àëüíàÿ èíèöèàëèçàöèÿ AlignRule
|
|
PrepareAlign(TempRank, AAxisArray, ACoeffArray, AConstArray, IniRule);
|
|
|
|
// Ôîðìèðîâàíèå ñóïåðïîçèöèè îòîáðàæåíèé
|
|
ArrRank = Rank();
|
|
ARSize = ArrRank + TempAMV->Rank();
|
|
// Rank ìàññèâà + Rank AMView êóäà ìàññèâ â èòîãå âûðàâíåí(ò.å. AM_Dis)
|
|
AlignRule = vector<AlignAxis>(ARSize);
|
|
AlignRule = IniRule;
|
|
|
|
/* LU deb
|
|
for(i=0;i<AlignRule.size();i++)
|
|
printf("%d %d %d %d ",AlignRule[i].A, AlignRule[i].B, AlignRule[i].Axis, AlignRule[i].TAxis);
|
|
printf("\n");
|
|
*/
|
|
|
|
for (i = 0; i < ArrRank; i++)
|
|
{
|
|
aAl = IniRule[i];
|
|
if (aAl.Attr == align_NORMAL)
|
|
{
|
|
tAl = TAlign[aAl.TAxis - 1];
|
|
switch (tAl.Attr)
|
|
{
|
|
case align_NORMAL : aAl.TAxis = tAl.TAxis;
|
|
aAl.A *= tAl.A;
|
|
aAl.B = aAl.B * tAl.A + tAl.B;
|
|
// IniRule[i] = AlignAxis(align_NORMAL, i+1, tAl.TAxis, aAl.A*tAl.A, aAl.B*tAl.A+tAl.B);
|
|
break;
|
|
case align_COLLAPSE : aAl.TAxis = 0;
|
|
aAl.Attr = align_COLLAPSE;
|
|
// IniRule[i] = AlignAxis(align_COLLAPSE, i+1, 0);
|
|
break;
|
|
}
|
|
}
|
|
AlignRule[i] = aAl;
|
|
}
|
|
|
|
#ifdef nodef
|
|
for (i = 0; i < TempAMV->Rank(); i++) {
|
|
AlignRule[i+ArrRank].Attr=TAlign[i+TempRank].Attr;
|
|
AlignRule[i+ArrRank].TAxis=TAlign[i+TempRank].TAxis;
|
|
AlignRule[i+ArrRank].A=TAlign[i+TempRank].A;
|
|
AlignRule[i+ArrRank].B=TAlign[i+TempRank].B;
|
|
AlignRule[i+ArrRank].Bound=TAlign[i+TempRank].Bound;
|
|
AlignRule[i+ArrRank].Axis=IniRule[i+TempRank].Axis;
|
|
}
|
|
#endif
|
|
// íà÷àëüíàÿ èíèö. 2-îé ÷àñòè ïðàâèëà
|
|
// âûðàâíèâàíèÿ (åñëè øàáëîí ðàçìíîæåí, òî è ìàññèâ òåì áîëåå)
|
|
|
|
|
|
for (i = 0; i < TempRank; i++)
|
|
{
|
|
aAl = IniRule[i+ArrRank];
|
|
switch (aAl.Attr)
|
|
{
|
|
case align_CONSTANT : tAl = TAlign[aAl.TAxis-1];
|
|
if (tAl.Attr == align_NORMAL)
|
|
{
|
|
aAl.TAxis = tAl.TAxis;
|
|
aAl.B = tAl.A * aAl.B + tAl.B;
|
|
AlignRule[ArrRank+tAl.TAxis-1] = aAl;
|
|
}
|
|
break;
|
|
case align_REPLICATE: tAl = TAlign[aAl.TAxis-1];
|
|
if (tAl.Attr == align_NORMAL)
|
|
{
|
|
aAl.Attr = align_BOUNDREPL;
|
|
aAl.TAxis = tAl.TAxis;
|
|
aAl.A = tAl.A;
|
|
aAl.B = tAl.B;
|
|
aAl.Bound = APattern->GetSize(tAl.TAxis);
|
|
AlignRule[ArrRank+tAl.TAxis-1] = aAl;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
#ifdef _TIME_TRACE_
|
|
// Íå íóæíî
|
|
prot << "AlignRule:" << endl;
|
|
vector<AlignAxis>::iterator first = AlignRule.begin(), last = AlignRule.end();
|
|
while(first != last)
|
|
{
|
|
prot << endl << first->Attr << " " << first->Axis << " " << first->TAxis
|
|
<< " " << first->A << " " << first->B << " " << first->Bound << endl;
|
|
++first;
|
|
}
|
|
#ifdef nodef
|
|
first = AlignRule.begin(),
|
|
last = AlignRule.end();
|
|
while(first != last)
|
|
{
|
|
assert(first->Axis!=0);
|
|
assert(first->TAxis!=0);
|
|
++first;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
/* LU deb
|
|
for(i=0;i<AlignRule.size();i++)
|
|
printf("%d %d %d %d ",AlignRule[i].A, AlignRule[i].B, AlignRule[i].Axis, AlignRule[i].TAxis);
|
|
printf("\n");
|
|
*/
|
|
|
|
|
|
}
|
|
|
|
double DArray::RAlnDA(AMView *APattern, const vector<long>& AAxisArray,
|
|
const vector<long>& ACoeffArray, const vector<long>& AConstArray,
|
|
long ANewSign)
|
|
{
|
|
if (!APattern->IsDistribute()) {
|
|
prot << "Wrong call RAlnDA" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
if (!IsAlign()) {
|
|
// ìàññèâ íå ðàñïðåäåëåí - align
|
|
AlnDA(APattern, AAxisArray, ACoeffArray, AConstArray);
|
|
return 0.0;
|
|
}
|
|
|
|
if ( ANewSign != 0) {
|
|
// îáíîâëåíèå ñîäåðæèìîãî ðàñïðåäåë¸ííîãî ìàññèâà
|
|
|
|
// óäàëÿåì óêàçàòåëü íà äàííûé ìàññèâ èç AMView íà êîòîðîå îí ðàñïðåäåëåí
|
|
AM_Dis->DelDA(this);
|
|
// âûðàâíèâàåì äàííûé ìàññèâ íà íîâûé øàáëîí
|
|
AlnDA(APattern, AAxisArray, ACoeffArray, AConstArray);
|
|
return 0.0;
|
|
}
|
|
|
|
double time;
|
|
DArray *oldDA = new DArray(*this);
|
|
CommCost *ralCost = new CommCost(AM_Dis->VM_Dis);
|
|
|
|
// óäàëÿåì óêàçàòåëü íà äàííûé ìàññèâ èç AMView íà êîòîðîå îí ðàñïðåäåëåí
|
|
AM_Dis->DelDA(this);
|
|
// óáðàòü ïîòîì âûâîä è ïîìåíÿòü int DelDA íà void DelDA
|
|
|
|
// òàê ôóíêöèè RAlnDA íè ÷åì íå îòëè÷àþòñÿ êðîìå ýòèõ âûçîâîâ
|
|
AlnDA(APattern, AAxisArray, ACoeffArray, AConstArray);
|
|
ralCost->Update(oldDA, this);
|
|
|
|
#ifdef _TIME_TRACE_
|
|
// ïîòîì óáðàòü
|
|
int i, j;
|
|
prot << endl;
|
|
for (i = 0; i < AM_Dis->VM_Dis->GetLSize(); i++) {
|
|
for (j = 0; j < AM_Dis->VM_Dis->GetLSize(); j++) {
|
|
prot << "[" << i << "]" << "[" << j << "] = " << ralCost->transfer[i][j] << "; ";
|
|
}
|
|
prot << endl;
|
|
}
|
|
// ïîòîì óáðàòü
|
|
#endif
|
|
|
|
time = ralCost->GetCost();
|
|
delete oldDA;
|
|
delete ralCost;
|
|
return time;
|
|
}
|
|
|
|
double DArray::RAlnDA(DArray *APattern, const vector<long>& AAxisArray,
|
|
const vector<long>& ACoeffArray, const vector<long>& AConstArray,
|
|
long ANewSign)
|
|
{
|
|
if (!APattern->IsAlign()) {
|
|
prot << "Wrong call RAlnDA" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
if (!IsAlign()) {
|
|
// ìàññèâ íå ðàñïðåäåëåí - align
|
|
AlnDA(APattern, AAxisArray, ACoeffArray, AConstArray);
|
|
return 0.0;
|
|
}
|
|
|
|
if ( ANewSign != 0) {
|
|
// îáíîâëåíèå ñîäåðæèìîãî ðàñïðåäåë¸ííîãî ìàññèâà
|
|
return 0.0;
|
|
}
|
|
|
|
// ìàññèâ è îáðàçåö ðàñïðåäåëåíû
|
|
|
|
double time;
|
|
DArray *oldDA = new DArray(*this);
|
|
CommCost *ralCost = new CommCost(AM_Dis->VM_Dis);
|
|
|
|
// óäàëÿåì óêàçàòåëü íà äàííûé ìàññèâ èç AMView íà êîòîðîå îí ðàñïðåäåëåí
|
|
AM_Dis->DelDA(this);
|
|
// óáðàòü ïîòîì âûâîä è ïîìåíÿòü int DelDA íà void DelDA
|
|
|
|
AlnDA(APattern, AAxisArray, ACoeffArray, AConstArray);
|
|
// printf("Ral begin\n");
|
|
ralCost->Update(oldDA, this);
|
|
// printf("Ral Update ended\n");
|
|
|
|
#ifdef _TIME_TRACE_
|
|
// ïîòîì óáðàòü
|
|
int i, j;
|
|
prot << endl;
|
|
for (i = 0; i < AM_Dis->VM_Dis->GetLSize(); i++) {
|
|
for (j = 0; j < AM_Dis->VM_Dis->GetLSize(); j++) {
|
|
prot << "[" << i << "]" << "[" << j << "] = " << ralCost->transfer[i][j] << "; ";
|
|
}
|
|
prot << endl;
|
|
}
|
|
// ïîòîì óáðàòü
|
|
#endif
|
|
|
|
time = ralCost->GetCost();
|
|
|
|
delete oldDA;
|
|
delete ralCost;
|
|
return time;
|
|
}
|
|
|
|
// -------------------- Distributed --> Distributed ---------------------------------
|
|
|
|
double ArrayCopy(DArray* AFromArray, const vector<long>& BFromInitIndexArray,
|
|
const vector<long>& BFromLastIndexArray, const vector<long>& BFromStepArray,
|
|
DArray* AToArray, const vector<long>& BToInitIndexArray,
|
|
const vector<long>& BToLastIndexArray, const vector<long>& BToStepArray)
|
|
{
|
|
double time;
|
|
long i,DimSize;
|
|
//====
|
|
long p1;
|
|
//was vector<LS> blockIni;
|
|
//=***
|
|
|
|
unsigned sz = BFromInitIndexArray.size();
|
|
unsigned szt= BToInitIndexArray.size();
|
|
unsigned j;
|
|
|
|
vector<long> AFromInitIndexArray(sz);
|
|
vector<long> AFromLastIndexArray(sz);
|
|
vector<long> AFromStepArray(sz);
|
|
|
|
vector<long> AToInitIndexArray(szt);
|
|
vector<long> AToLastIndexArray(szt);
|
|
vector<long> AToStepArray(szt);
|
|
//====
|
|
// printf("Distr-Distr; Replicated %d %d \n",AToArray->Repl,AFromArray->Repl);
|
|
//=***
|
|
|
|
for ( j = 0; j < sz; j++) {
|
|
DimSize = AFromArray->SizeArray[j];
|
|
if (BFromInitIndexArray[j] == -1) {
|
|
AFromInitIndexArray[j] = 0;
|
|
AFromLastIndexArray[j] = AFromArray->GetSize(j + 1) - 1;
|
|
AFromStepArray[j] = 1;
|
|
} else {
|
|
AFromInitIndexArray[j] = BFromInitIndexArray[j];
|
|
AFromLastIndexArray[j] = BFromLastIndexArray[j];
|
|
AFromStepArray[j] = BFromStepArray[j];
|
|
if (AFromInitIndexArray[j] > AFromLastIndexArray[j])
|
|
AFromLastIndexArray[j] = AFromLastIndexArray[j];
|
|
if (AFromLastIndexArray[j] >= DimSize)
|
|
AFromLastIndexArray[j] = DimSize - 1;
|
|
}
|
|
}
|
|
|
|
for ( j = 0; j < szt; j++) {
|
|
if (BToInitIndexArray[j] == -1) {
|
|
AToInitIndexArray[j] = 0;
|
|
AToLastIndexArray[j] = AToArray->GetSize(j + 1) - 1;
|
|
AToStepArray[j] = 1;
|
|
} else {
|
|
AToInitIndexArray[j] = BToInitIndexArray[j];
|
|
AToLastIndexArray[j] = BToLastIndexArray[j];
|
|
AToStepArray[j] = BToStepArray[j];
|
|
}
|
|
}
|
|
|
|
CommCost *copyCost = new CommCost(AFromArray->AM_Dis->VM_Dis);
|
|
|
|
if (!AFromArray->CheckIndex(AFromInitIndexArray, AFromLastIndexArray, AFromStepArray))
|
|
{
|
|
prot << "Wrong call ArrayCopy" << endl;
|
|
exit(1);
|
|
}
|
|
if (!AToArray->CheckIndex(AToInitIndexArray, AToLastIndexArray, AToStepArray))
|
|
{
|
|
prot << "Wrong call ArrayCopy" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
//====
|
|
/* was
|
|
for (i = 0; i < AFromArray->Rank(); i++) {
|
|
// cout << AFromArray->Rank() << endl;
|
|
// cout << "AFromInitIndexArray[" << i << "] = " << AFromInitIndexArray[i] << endl;
|
|
// cout << "AFromLastIndexArray[" << i << "] = " << AFromLastIndexArray[i] << endl;
|
|
blockIni.push_back(LS(AFromInitIndexArray[i], AFromLastIndexArray[i]));
|
|
}
|
|
|
|
i = 5;
|
|
|
|
Block readBlock(blockIni);
|
|
|
|
if (AFromArray->Repl)
|
|
time = 0;
|
|
else {
|
|
copyCost->CopyUpdate(AFromArray, readBlock);
|
|
time = copyCost->GetCost();
|
|
}
|
|
*/
|
|
|
|
//òóò áûë öèêë ñ cout & i=5; & Block...
|
|
//=***
|
|
if (AFromArray->Repl)
|
|
time = 0;
|
|
else {
|
|
//====
|
|
if(AToArray->Repl)
|
|
{
|
|
//=***
|
|
vector<LS> blockIni;
|
|
|
|
for (i = 0; i < AFromArray->Rank(); i++) {
|
|
// cout << AFromArray->Rank() << endl;
|
|
// cout << "AFromInitIndexArray[" << i << "] = " << AFromInitIndexArray[i] << endl;
|
|
// cout << "AFromLastIndexArray[" << i << "] = " << AFromLastIndexArray[i] << endl;
|
|
// cout << "AFromStepArray[" << i << "] = " << AFromStepArray[i] << endl;
|
|
if(AFromStepArray[i]>0)
|
|
blockIni.push_back(LS(AFromInitIndexArray[i], AFromLastIndexArray[i], AFromStepArray[i]));
|
|
else
|
|
blockIni.push_back(LS(AFromLastIndexArray[i], AFromInitIndexArray[i], -AFromStepArray[i]));
|
|
}
|
|
|
|
Block readBlock(blockIni);
|
|
copyCost->CopyUpdate(AFromArray, readBlock);
|
|
time = copyCost->GetCost();
|
|
// printf("Synch=%d time=%f\n",SynchCopy,time);
|
|
|
|
//====
|
|
}
|
|
else
|
|
{ long x1,x2,x3;
|
|
|
|
for (p1 = 0; p1 < copyCost->GetLSize(); p1++) {
|
|
vector<LS> blockIni;
|
|
vector<LS> blockIni1;
|
|
|
|
Block locBlock(AToArray, p1, 1);
|
|
|
|
for (i = 0; i < AToArray->Rank(); i++)
|
|
{ if(AToStepArray[i]>0)
|
|
blockIni1.push_back(LS(AToInitIndexArray[i], AToLastIndexArray[i], AToStepArray[i]));
|
|
else
|
|
blockIni1.push_back(LS(AToLastIndexArray[i], AToInitIndexArray[i], -AToStepArray[i]));
|
|
}
|
|
Block writeBlock(blockIni1);
|
|
|
|
//printf("lockAll[%d].0=%d-%d\n",p1,locBlock.GetLower(0),locBlock.GetUpper(0));
|
|
//printf("lockAll[%d].0=%d-%d\n",p1,locBlock.GetLower(1),locBlock.GetUpper(1));
|
|
//printf("lockAll[%d].empty=%d\n",p1,locBlock.empty());
|
|
//printf("writeBl[%d].1=%d-%d\n",p1,writeBlock.GetLower(0),writeBlock.GetUpper(0));
|
|
//printf("writeBl[%d].1=%d-%d\n",p1,writeBlock.GetLower(1),writeBlock.GetUpper(1));
|
|
Block writeLocBlock = locBlock ^ writeBlock;
|
|
|
|
if(writeLocBlock.empty()) continue; //áëîê âû÷èñëåíèé íå íà ýòîì ïðîöåññîðå
|
|
//printf("ATo[%d].0=%d-%d\n",p1,writeLocBlock.GetLower(0),writeLocBlock.GetUpper(0));
|
|
//printf("ATo[%d].1=%d-%d\n",p1,writeLocBlock.GetLower(1),writeLocBlock.GetUpper(1));
|
|
|
|
for (i = 0; i < AFromArray->Rank(); i++)
|
|
{
|
|
// printf("FROM ***%d-%d***\n",AFromInitIndexArray[i],AFromLastIndexArray[i]);
|
|
|
|
if(AToStepArray[i]==0 && AToInitIndexArray[i]==AToLastIndexArray[i]) AToStepArray[i]=1; // åñëè êîïèðóåòñÿ â îäíó ñòðîêó, òî øàã íå ñ÷èòàòü íóëåâûì à ìîæíî ñ÷èòàòü êàêèì óãîäíî, íàïðèìåð åäèíèöåé
|
|
|
|
if(AFromStepArray[i]>0 && AToStepArray[i]>0)
|
|
x1 = AFromInitIndexArray[i] + (writeLocBlock.GetLower(i) - AToInitIndexArray[i])*(AFromStepArray[i]/AToStepArray[i]);
|
|
if(AFromStepArray[i]>0 && AToStepArray[i]<0)
|
|
x1 = AFromInitIndexArray[i] + (writeLocBlock.GetLower(i) - AToLastIndexArray[i])*(-AFromStepArray[i]/AToStepArray[i]);
|
|
|
|
if(AFromStepArray[i]<=0 && AToStepArray[i]>0)
|
|
x1 = AFromLastIndexArray[i] + (writeLocBlock.GetLower(i) - AToInitIndexArray[i])*(-AFromStepArray[i]/AToStepArray[i]);
|
|
if(AFromStepArray[i]<=0 && AToStepArray[i]<0)
|
|
x1 = AFromLastIndexArray[i] + (writeLocBlock.GetLower(i) - AToLastIndexArray[i])*(AFromStepArray[i]/AToStepArray[i]);
|
|
|
|
x2 = x1 + (writeLocBlock.GetUpper(i) - writeLocBlock.GetLower(i))*(abs(AFromStepArray[i]/AToStepArray[i]));
|
|
x3 = abs(AFromStepArray[i]);
|
|
|
|
blockIni.push_back(LS(x1,x2,x3));
|
|
}
|
|
|
|
Block readBlock(blockIni);
|
|
// printf("AFrom[%d].0=%d-%d\n",p1,readBlock.GetLower(0),readBlock.GetUpper(0));
|
|
// printf("AFrom[%d].1=%d-%d\n",p1,readBlock.GetLower(1),readBlock.GetUpper(1));
|
|
|
|
copyCost->CopyUpdateDistr(AFromArray, readBlock, p1);
|
|
}
|
|
time = copyCost->GetCost();
|
|
|
|
// printf("Synch=%d time=%f\n",SynchCopy,time);
|
|
|
|
}
|
|
//=***
|
|
}
|
|
|
|
#ifdef _TIME_TRACE_
|
|
// ïîòîì óáðàòü
|
|
//long j;
|
|
prot << endl;
|
|
for (i = 0; i < AFromArray->AM_Dis->VM_Dis->GetLSize(); i++)
|
|
{
|
|
for (j = 0; j < AFromArray->AM_Dis->VM_Dis->GetLSize(); j++)
|
|
{
|
|
prot << "[" << i << "]" << "[" << j << "] = " << copyCost->transfer[i][j] << "; ";
|
|
}
|
|
prot << endl;
|
|
}
|
|
// ïîòîì óáðàòü
|
|
#endif
|
|
|
|
// ??? òàê âîáùåì-òî âñ¸, íî â áóäóùåì ñþäà íàäî äîáàâèòü åùå äâà âèäà êîïèðîâàíèÿ
|
|
// îäèí - ñ íå ðàñïðåäåëåííîãî ìàññèâà íà ðàñïðåäåëåííûé(ìîæíî è ñå÷àñ äîáàâèòü òàê êàê time = 0
|
|
// äðóãîé - êîãäà îáà ìàññèâà ðàñïðåäåëåííû(ýòî õóæå)
|
|
// ýòî íå ðàññìàòðèâàÿ ñëó÷àÿ ñ ïðîöåññîðîì ââîäà-âûâîäà
|
|
delete copyCost;
|
|
return time;
|
|
}
|
|
|
|
// -------------------- Distributed --> Replicated ---------------------------------
|
|
//×òî òî ó ìåíÿ ýòà ôóêíöèÿ âûçûâàëàñü òîëüêî íà sor îäíîìåðíîì íà ôîðòðàíå íàïèñàííîì ïðè êîèïðîâàíèè â ôàéë ìàññèâà
|
|
|
|
double ArrayCopy(DArray* AFromArray, const vector<long>& BFromInitIndexArray,
|
|
const vector<long>& BFromLastIndexArray, const vector<long>& BFromStepArray,
|
|
long ACopyRegim)
|
|
{
|
|
double time;
|
|
long i;
|
|
long DimSize;
|
|
vector<LS> blockIni;
|
|
Block readBlock;
|
|
unsigned sz = BFromInitIndexArray.size();
|
|
unsigned j;
|
|
// printf("Distr-Repl; Replicated %d \n",AFromArray->Repl);
|
|
|
|
vector<long> AFromInitIndexArray(sz);
|
|
vector<long> AFromLastIndexArray(sz);
|
|
vector<long> AFromStepArray(sz);
|
|
|
|
for ( j = 0; j < sz; j++) {
|
|
DimSize = AFromArray->SizeArray[j];
|
|
if (BFromInitIndexArray[j] == -1) {
|
|
AFromInitIndexArray[j] = 0;
|
|
AFromLastIndexArray[j] = AFromArray->GetSize(j + 1) - 1;
|
|
AFromStepArray[j] = 1;
|
|
} else {
|
|
AFromInitIndexArray[j] = BFromInitIndexArray[j];
|
|
AFromLastIndexArray[j] = BFromLastIndexArray[j];
|
|
AFromStepArray[j] = BFromStepArray[j];
|
|
if (AFromInitIndexArray[j] > AFromLastIndexArray[j])
|
|
AFromLastIndexArray[j] = AFromLastIndexArray[j];
|
|
if (AFromLastIndexArray[j] >= DimSize)
|
|
AFromLastIndexArray[j] = DimSize - 1;
|
|
}
|
|
}
|
|
#ifdef P_DEBUG
|
|
prot << "ArrayCopy: " << *AFromArray;
|
|
prot << "ArrayCopy: AFromInitIndexArray: ";
|
|
for ( j = 0; j < sz; j++)
|
|
prot << AFromInitIndexArray[j] << ',';
|
|
prot << endl;
|
|
prot << "ArrayCopy: AFromLastIndexArray: ";
|
|
for ( j = 0; j < sz; j++)
|
|
prot << AFromLastIndexArray[j] << ',';
|
|
prot << endl;
|
|
prot << "ArrayCopy: AFromStepArray: ";
|
|
for ( j = 0; j < sz; j++)
|
|
prot << AFromStepArray[j] << ',';
|
|
prot << endl;
|
|
#endif
|
|
|
|
CommCost *copyCost = new CommCost(AFromArray->AM_Dis->VM_Dis);
|
|
|
|
if (!AFromArray->CheckIndex(AFromInitIndexArray, AFromLastIndexArray, AFromStepArray)) {
|
|
prot << "Wrong call ArrayCopy" << endl;
|
|
exit(1);
|
|
}
|
|
|
|
for (i = 0; i < AFromArray->Rank(); i++) {
|
|
blockIni.push_back(LS(AFromInitIndexArray[i], AFromLastIndexArray[i]));
|
|
}
|
|
readBlock = Block(blockIni);
|
|
|
|
if (AFromArray->Repl)
|
|
time = 0;
|
|
else{
|
|
//====
|
|
int p1;
|
|
for (p1 = 0; p1 < copyCost->GetLSize(); p1++) {
|
|
vector<LS> blockIni;
|
|
|
|
for (i = 0; i < AFromArray->Rank(); i++) {
|
|
//printf("***%d %d - %d %d***\n",AFromInitIndexArray[i],AFromLastIndexArray[i],AFromInitIndexArray[i]+locBlock.GetLower(i),AFromInitIndexArray[i]+locBlock.GetUpper(i));
|
|
if(AFromStepArray[i]>0)
|
|
blockIni.push_back(LS(AFromInitIndexArray[i], AFromInitIndexArray[i], AFromStepArray[i]));
|
|
else
|
|
blockIni.push_back(LS(AFromLastIndexArray[i], AFromLastIndexArray[i], -AFromStepArray[i]));
|
|
}
|
|
Block readBlock(blockIni);
|
|
|
|
copyCost->CopyUpdateDistr(AFromArray, readBlock, p1);
|
|
}
|
|
time = copyCost->GetCost();
|
|
// printf("Synch=%d time=%f\n",SynchCopy,time);
|
|
}
|
|
//=***
|
|
|
|
#ifdef _TIME_TRACE_
|
|
// ïîòîì óáðàòü
|
|
//long j;
|
|
prot << endl;
|
|
for (i = 0; i < AFromArray->AM_Dis->VM_Dis->GetLSize(); i++)
|
|
{
|
|
for (j = 0; j < AFromArray->AM_Dis->VM_Dis->GetLSize(); j++)
|
|
{
|
|
prot << "[" << i << "]" << "[" << j << "] = " << copyCost->transfer[i][j] << "; ";
|
|
}
|
|
prot << endl;
|
|
}
|
|
// ïîòîì óáðàòü
|
|
#endif
|
|
|
|
// ??? òàê âîáùåì-òî âñ¸, íî â áóäóùåì ñþäà íàäî äîáàâèòü åùå äâà âèäà êîïèðîâàíèÿ
|
|
// îäèí - ñ íå ðàñïðåäåëåííîãî ìàññèâà íà ðàñïðåäåëåííûé(ìîæíî è ñå÷àñ äîáàâèòü òàê êàê time = 0
|
|
// äðóãîé - êîãäà îáà ìàññèâà ðàñïðåäåëåííû(ýòî õóæå)
|
|
// ýòî íå ðàññìàòðèâàÿ ñëó÷àÿ ñ ïðîöåññîðîì ââîäà-âûâîäà
|
|
delete copyCost;
|
|
return time;
|
|
}
|
|
|
|
DArray::DArray(const DArray &x) : Space(x)
|
|
{
|
|
TypeSize = x.TypeSize;
|
|
AM_Dis = x.AM_Dis;
|
|
AlignRule = x.AlignRule;
|
|
Repl = x.Repl;
|
|
}
|
|
|
|
DArray & DArray::operator =(const DArray & x)
|
|
{
|
|
if (this != &x) {
|
|
Space::operator =(x);
|
|
TypeSize = x.TypeSize;
|
|
AM_Dis = x.AM_Dis;
|
|
AlignRule = x.AlignRule;
|
|
Repl = x.Repl;
|
|
}
|
|
return * this;
|
|
}
|
|
|
|
DArray::DArray() : Space()
|
|
{
|
|
TypeSize = 0;
|
|
AM_Dis = 0;
|
|
AlignRule = vector<AlignAxis>(0);
|
|
Repl = 0;
|
|
}
|
|
|
|
bool DArray::IsAlign()
|
|
{
|
|
if (AM_Dis == 0)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
long DArray::GetMapDim(long arrDim, int & dir)
|
|
{
|
|
long vmDim = 0;
|
|
AlignAxis align;
|
|
DistAxis dist;
|
|
long amDim;
|
|
|
|
|
|
if(arrDim<=0)
|
|
{
|
|
|
|
printf("arrDim<=0\n");
|
|
dir=1; // not sure in it
|
|
return 0; // not much sure in it
|
|
}
|
|
align = AlignRule[arrDim-1];
|
|
|
|
if (align.Attr == align_NORMAL)
|
|
{
|
|
amDim = align.TAxis;
|
|
dir = (align.A > 0) ? 1 : -1;
|
|
dist = AM_Dis->DistRule[amDim-1];
|
|
if(dist.Attr == map_BLOCK)
|
|
vmDim = dist.PAxis;
|
|
}
|
|
return vmDim;
|
|
}
|
|
|
|
long DArray::CheckIndex(const vector<long>& InitIndexArray,
|
|
vector<long>& LastIndexArray, const vector<long>& StepArray)
|
|
{
|
|
int i;
|
|
long DimSize, BlockSize = 1;
|
|
|
|
for (i = 0; i < Rank(); i++) {
|
|
DimSize = SizeArray[i];
|
|
|
|
if ((InitIndexArray[i] >= DimSize || InitIndexArray[i] < 0) ||
|
|
(LastIndexArray[i] >= DimSize || LastIndexArray[i] < 0)) { //====//=*** â áóäóùåì çàìåíèòü íà <= 0 //was (StepArray[i] !=1)
|
|
prot << "i = " << i << " InitIndexArray[i] = " << InitIndexArray[i]
|
|
<< " LastIndexArray[i] = " << LastIndexArray[i]
|
|
<< " StepArray[i] = " << StepArray[i]
|
|
<< " DimSize = " << DimSize <<endl;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// âû÷èñëåíèå ÷èñëà ýëåìåíòîâ â áëîêå
|
|
for (i = 0; i < Rank(); i++) {
|
|
//=== change if
|
|
// printf("Step=%d\n",StepArray[i]);
|
|
if(StepArray[i]!=0)
|
|
DimSize = (LastIndexArray[i] - InitIndexArray[i]) / StepArray[i] + 1; // äëÿ ñëó÷àÿ êîãäà |Step| ìîæåò áûòü > 1
|
|
else
|
|
DimSize = 1;
|
|
//was if ((LastIndexArray[i] - InitIndexArray[i]) % StepArray[i])
|
|
//was DimSize++;
|
|
//=***
|
|
BlockSize *= DimSize;
|
|
}
|
|
|
|
return BlockSize;
|
|
}
|
|
|
|
double DArray::RDisDA(const vector<long>& AAxisArray, const vector<long>& ADistrParamArray, long ANewSign)
|
|
{
|
|
return AM_Dis->RDisAM(AAxisArray, ADistrParamArray, ANewSign);
|
|
}
|
|
|
|
|
|
#ifdef P_DEBUG
|
|
ostream& operator << (ostream& os, const DArray& da)
|
|
{
|
|
int i;
|
|
|
|
os << "DArray: TypeSize = " << da.TypeSize << ", AM_Dis = " << (void*) da.AM_Dis <<endl;
|
|
os << " " << (Space&) da;
|
|
os << " " << "LowShdWidthArray:HiShdWidthArray = ";
|
|
for (i = 0; i < da.LowShdWidthArray.size(); i++)
|
|
os << da.LowShdWidthArray[i] << ':' << da.HiShdWidthArray[i] << ' ';
|
|
os << endl;
|
|
os << " AlignRule:" << endl;
|
|
for (i = 0; i < da.AlignRule.size(); i++)
|
|
os << " " << i << ' ' << da.AlignRule[i] << endl;
|
|
|
|
return os;
|
|
}
|
|
#endif
|