Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
75e89ab8689e463f459c96fe9c4304eb8d3960ad
SAPFOR/Sapfor/_src/Predictor/Lib/CallParams.cpp

2192 lines
70 KiB
C++
Raw Normal View History

added project
2023-09-14 19:43:13 +03:00
#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <limits.h>
#include <fstream>
#include "CallInfoStructs.h"
#include "ParseString.h"
#include "Ver.h"
#include "TraceLine.h"
#include "Interval.h"
//====
#include <stdio.h>
//=***
#ifdef __GNUC__
#define _strdup strdup
#endif
using namespace std;
static Event global_func_id;
static int global_source_line;
static char* global_source_file;
//====
//int ShdWid[10];
long TraceProcNum;
//=***
extern ofstream prot;
TraceCall::TraceCall(Event p_func_id, int p_source_line, char* p_source_file, int p_call_info_count,
char** p_call_info, int p_ret_info_count, char** p_ret_info) :
func_id(p_func_id),
source_line(p_source_line),
source_file(p_source_file),
call_info_count(p_call_info_count),
call_info(p_call_info),
ret_info_count(p_ret_info_count),
ret_info(p_ret_info)
{
}
// Service functions headers
long* GetArrayParam(char* param_name, char** str_list, int str_count);
double* GetArrayParamD(char* param_name, char** str_list, int str_count);
unsigned long* GetVectorParam(char* param_name, char** str_list, int str_count);
// Internal routines
Event func_id;
static int arrayRank; // modified by "GetArrayParam"
void ParamNotFoundErr(char* param)
{
cerr << "ERROR [" << global_source_file << ':' << global_source_line << ':' << global_func_id << "] : '" << param << "' parameter missing" << endl;
prot << "ERROR [" << global_source_file << ':' << global_source_line << ':' << global_func_id << "] : '" << param << "' parameter missing" << endl;
abort();
}
/* InfoStruct functions */
IDOnlyInfo* Get_IDOnlyInfo(char* param_name, char** str_list, int str_count, int base)
{
long tmp_l;
if (ParamFromStrArr(param_name, tmp_l, str_list, str_count, base)) {
IDOnlyInfo* tmp = new IDOnlyInfo;
assert(tmp != NULL);
tmp->ID = tmp_l;
return tmp;
} else {
ParamNotFoundErr(param_name);
return NULL;
}
}
binter_Info* Get_binter_Info(TraceCall& trc_call)
{
binter_Info* tmp = new binter_Info;
assert(tmp != NULL);
tmp->line=trc_call.source_line;
tmp->file=_strdup(trc_call.source_file);
tmp->index = 0;
if (!ParamFromStrArr("index", tmp->index, trc_call.call_info,
trc_call.call_info_count, 10))
tmp->index = NO_EXPR;
return tmp;
}
//-------------------------------------------- Get_getps_Info ------------------------------------------
getps_Info* Get_getps_Info(TraceCall& trc_call)
{
getps_Info* tmp = new getps_Info;
bool error = false;
if (!ParamFromStrArr("AMRef", tmp->AMRef, trc_call.call_info,
trc_call.call_info_count, 16)) {
ParamNotFoundErr("AMRef");
error = true;
} else if (!ParamFromStrArr("PSRef", tmp->PSRef, trc_call.ret_info,
trc_call.ret_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
}
return tmp;
}
//-------------------------------------------- Get_crtps_Info ------------------------------------------
crtps_Info* Get_crtps_Info(TraceCall& trc_call)
{
crtps_Info* tmp = new crtps_Info;
long *AInitIndexArray = NULL;
long *ALastIndexArray = NULL;
bool error = false;
if (!ParamFromStrArr("PSRef", tmp->PSRefParent, trc_call.call_info,
trc_call.call_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
} else if (!ParamFromStrArr("StaticSign", tmp->StaticSign, trc_call.call_info,
trc_call.call_info_count, 10)) {
ParamNotFoundErr("StaticSign");
error = true;
} else if ((AInitIndexArray = GetArrayParam("InitIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InitIndexArray");
error = true;
} else if ((ALastIndexArray = GetArrayParam("LastIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LastIndexArray");
error = true;
} else if (!ParamFromStrArr("PSRef", tmp->PSRef, trc_call.ret_info,
trc_call.ret_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
}
if (error) {
delete [] AInitIndexArray;
delete [] ALastIndexArray;
delete tmp;
tmp = NULL;
} else {
tmp->InitIndexArray.resize(arrayRank);
tmp->LastIndexArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->InitIndexArray[i] = AInitIndexArray[i];
tmp->LastIndexArray[i] = ALastIndexArray[i];
}
delete [] AInitIndexArray;
delete [] ALastIndexArray;
}
return tmp;
}
//-------------------------------------------- Get_psview_Info ------------------------------------------
psview_Info* Get_psview_Info(TraceCall& trc_call)
{
psview_Info* tmp = new psview_Info;
long *ASizeArray = NULL;
bool error = false;
if (!ParamFromStrArr("PSRef", tmp->PSRefParent, trc_call.call_info,
trc_call.call_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
} else if (!ParamFromStrArr("Rank", tmp->Rank, trc_call.call_info,
trc_call.call_info_count, 10)) {
ParamNotFoundErr("Rank");
error = true;
} else if (!ParamFromStrArr("StaticSign", tmp->StaticSign, trc_call.call_info,
trc_call.call_info_count, 10)) {
ParamNotFoundErr("StaticSign");
error = true;
} else if ((ASizeArray = GetArrayParam("SizeArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("SizeArray");
error = true;
} else if (!ParamFromStrArr("PSRef", tmp->PSRef, trc_call.ret_info,
trc_call.ret_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
}
if (error) {
delete [] ASizeArray;
delete tmp;
tmp = NULL;
} else {
tmp->SizeArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++)
tmp->SizeArray[i] = ASizeArray[i];
delete [] ASizeArray;
}
return tmp;
}
//-------------------------------------------- Get_setelw_Info ------------------------------------------
/*
long PSRef; // 16
long AMViewRef; // 16
long AddrNumber; // 10
std::vector<long> WeightNumber;
// length = sun i = [0,AddrNumber-1] WeightNumber[i]
std:vector<double> LoadWeight;
*/
setelw_Info* Get_setelw_Info(TraceCall& trc_call)
{
setelw_Info* tmp = new setelw_Info;
long *AWeightNumber = NULL;
double *ALoadWeight = NULL;
bool error = false;
if (!ParamFromStrArr("PSRef", tmp->PSRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
} else if (!ParamFromStrArr("AMViewRef", tmp->AMViewRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("AMViewRef");
error = true;
} else if (!ParamFromStrArr("AddrNumber", tmp->AddrNumber, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("AddrNumber");
error = true;
}
//grig/*
else if ((AWeightNumber = GetArrayParam("WeightNumber", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("WeightNumber");
error = true;
} else if ((ALoadWeight = (double *) GetArrayParamD("LoadWeight", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LoadWeight");
error = true;
}
//grig*/
if (error) {
delete [] AWeightNumber;
delete [] ALoadWeight;
delete tmp;
tmp = NULL;
} else {
tmp->WeightNumber.resize(arrayRank);
tmp->LoadWeight.resize(arrayRank); // arrayRank
for (int i=0; i < arrayRank; i++) {
tmp->WeightNumber[i] = AWeightNumber[i];
tmp->LoadWeight[i] = ALoadWeight[i];
}
delete [] AWeightNumber;
delete [] ALoadWeight;
}
return tmp;
}
//-------------------------------------------- Get_getamr_Info ------------------------------------------
getamr_Info* Get_getamr_Info(TraceCall& trc_call)
{
getamr_Info* tmp = new getamr_Info;
long *AIndexArray = NULL;
bool error = false;
if (!ParamFromStrArr("AMViewRef", tmp->AMViewRef, trc_call.call_info,
trc_call.call_info_count, 16)) {
ParamNotFoundErr("AMViewRef");
error = true;
} else if ((AIndexArray = GetArrayParam("IndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("IndexArray");
error = true;
} else if (!ParamFromStrArr("AMRef", tmp->AMRef, trc_call.ret_info,
trc_call.ret_info_count, 16)) {
ParamNotFoundErr("AMRef");
error = true;
}
if (error) {
delete [] AIndexArray;
delete tmp;
tmp = NULL;
} else {
tmp->IndexArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++)
tmp->IndexArray[i] = AIndexArray[i];
delete [] AIndexArray;
}
return tmp;
}
//-------------------------------------------- Get_getamv_Info ------------------------------------------
getamv_Info* Get_getamv_Info(TraceCall& trc_call)
{
getamv_Info* tmp = new getamv_Info;
bool error = false;
if (!ParamFromStrArr("ArrayHeader", tmp->ArrayHeader, trc_call.call_info,
trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHeader");
error = true;
} else if (!ParamFromStrArr("AMViewRef", tmp->AMViewRef, trc_call.ret_info,
trc_call.ret_info_count, 16)) {
ParamNotFoundErr("AMViewRef");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
}
return tmp;
}
//-------------------------------------------- Get_getamv_Info ------------------------------------------
mapam_Info* Get_mapam_Info(TraceCall& trc_call)
{
mapam_Info* tmp = new mapam_Info;
bool error = false;
if (!ParamFromStrArr("AMRef", tmp->AMRef, trc_call.call_info,
trc_call.call_info_count, 16)) {
ParamNotFoundErr("AMRef");
error = true;
} else if (!ParamFromStrArr("PSRef", tmp->PSRef, trc_call.call_info,
trc_call.call_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
}
return tmp;
}
//-------------------------------------------- Get_crtamv_Info ------------------------------------------
crtamv_Info* Get_crtamv_Info(TraceCall& trc_call)
{
crtamv_Info* tmp = new crtamv_Info;
long *ASizeArray = NULL;
long rank =0;
bool error = false;
if (!ParamFromStrArr("AMRef", tmp->AM_ID, trc_call.call_info,
trc_call.call_info_count, 16)) {
ParamNotFoundErr("AMRef");
error = true;
} else if (!ParamFromStrArr("AMViewRef", tmp->ID, trc_call.ret_info,
trc_call.ret_info_count, 16)) {
ParamNotFoundErr("AMViewRef");
error = true;
} else if (!ParamFromStrArr("StaticSign", tmp->StaticSign, trc_call.call_info,
trc_call.call_info_count, 10)) {
ParamNotFoundErr("StaticSign");
error = true;
} else if (!ParamFromStrArr("Rank", rank, trc_call.call_info,
trc_call.call_info_count, 10)) {
ParamNotFoundErr("Rank");
error = true;
} else if ((ASizeArray = GetArrayParam("SizeArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("SizeArray");
error = true;
}
if (error) {
delete [] ASizeArray;
delete tmp;
tmp = NULL;
} else {
tmp->SizeArray.resize(rank);
for (int i=0; i < rank; i++)
tmp->SizeArray[i] = ASizeArray[i];
delete [] ASizeArray;
}
return tmp;
}
//====
//-------------------------------------------- Get_blkdiv_Info ------------------------------------------
blkdiv_Info* Get_blkdiv_Info(TraceCall& trc_call)
{
blkdiv_Info* tmp = new blkdiv_Info;
long *AxisArray = NULL;
long rank = 0;
bool error = false;
if (!ParamFromStrArr("AMViewRef", tmp->ID, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("AMViewRef");
error = true;
} else if (!ParamFromStrArr("AMVAxisCount", rank, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("AMVAxisCount");
error = true;
} else if (rank > 0) {
if ((AxisArray=GetArrayParam("AMVAxisDiv", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("AMVAxisDiv");
error = true;
}
}
if (error) {
delete tmp;
tmp = NULL;
delete [] AxisArray;
} else {
tmp->AMVAxisDiv.resize(rank);
for (int i=0; i < rank; i++) {
tmp->AMVAxisDiv[i] = AxisArray[i];
}
delete [] AxisArray;
}
return tmp;
}
//=***
//-------------------------------------------- Get_distr_Info ------------------------------------------
distr_Info* Get_distr_Info(TraceCall& trc_call)
{
distr_Info* tmp = new distr_Info;
long *AxisArray = NULL;
long *DistrParamArray = NULL;
long rank = 0;
bool error = false;
if (!ParamFromStrArr("AMViewRef", tmp->ID, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("AMViewRef");
error = true;
} else if (!ParamFromStrArr("PSRef", tmp->PSRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
} else if (!ParamFromStrArr("ParamCount", rank, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("ParamCount");
error = true;
} else if (rank > 0) {
if ((AxisArray=GetArrayParam("AxisArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("AxisArray");
error = true;
} else if ((DistrParamArray=GetArrayParam("DistrParamArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("DistrParamArray");
error = true;
}
}
if (error) {
delete tmp;
tmp = NULL;
delete [] AxisArray;
delete [] DistrParamArray;
} else {
tmp->AxisArray.resize(rank);
tmp->DistrParamArray.resize(rank);
for (int i=0; i < rank; i++) {
tmp->AxisArray[i] = AxisArray[i];
tmp->DistrParamArray[i] = DistrParamArray[i];
}
delete [] AxisArray;
delete [] DistrParamArray;
}
return tmp;
}
//-------------------------------------------- Get_redis_Info ------------------------------------------
redis_Info* Get_redis_Info(TraceCall& trc_call)
{
redis_Info* tmp = new redis_Info;
long *AxisArray = NULL;
long *DistrParamArray = NULL;
long rank = 0;
bool error = false;
tmp->ID = 0;
tmp->AID = 0;
if ((!ParamFromStrArr("AMViewRef", tmp->ID, trc_call.call_info, trc_call.call_info_count, 16)) &&
(!ParamFromStrArr("ArrayHeader", tmp->AID, trc_call.call_info, trc_call.call_info_count, 16))) {
ParamNotFoundErr("AMViewRef/ArrayHeader");
error = true;
} else if (!ParamFromStrArr("PSRef", tmp->PSRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
} else if (!ParamFromStrArr("ParamCount", rank, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("ParamCount");
error = true;
} else if(!ParamFromStrArr("NewSign", tmp->NewSign, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("NewSign");
error = true;
} else if ((AxisArray=GetArrayParam("AxisArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("AxisArray");
error = true;
} else if ((DistrParamArray=GetArrayParam("DistrParamArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("DistrParamArray");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
delete [] AxisArray;
delete [] DistrParamArray;
} else {
tmp->AxisArray.resize(rank);
tmp->DistrParamArray.resize(rank);
for (int i=0; i < rank; i++) {
tmp->AxisArray[i] = AxisArray[i];
tmp->DistrParamArray[i] = DistrParamArray[i];
}
delete [] AxisArray;
delete [] DistrParamArray;
}
return tmp;
}
//-------------------------------------------- Get_crtda_Info ------------------------------------------
crtda_Info* Get_crtda_Info(TraceCall& trc_call)
{
long rank = 0;
long * SizeArray = NULL;
long * LowShdWidthArray = NULL;
long * HiShdWidthArray = NULL;
bool error = false;
crtda_Info* tmp = new crtda_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("ArrayHandlePtr", tmp->ArrayHandlePtr, trc_call.ret_info, trc_call.ret_info_count, 16)) {
ParamNotFoundErr("ArrayHandlePtr");
error = true;
} else if (!ParamFromStrArr("ArrayHeader", tmp->ArrayHeader, trc_call.call_info,
trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHeader");
error = true;
} else if(!ParamFromStrArr("Rank", rank , trc_call.call_info,
trc_call.call_info_count, 10)) {
ParamNotFoundErr("Rank");
error = true;
} else if (!ParamFromStrArr("TypeSize", tmp->TypeSize, trc_call.call_info,
trc_call.call_info_count, 10)) {
ParamNotFoundErr("TypeSize");
error = true;
} else if (!ParamFromStrArr("StaticSign", tmp->StaticSign, trc_call.call_info,
trc_call.call_info_count, 10)) {
ParamNotFoundErr("StaticSign");
error = true;
} else if (!ParamFromStrArr("ReDistrSign", tmp->ReDistrSign, trc_call.call_info,
trc_call.call_info_count, 10)) {
ParamNotFoundErr("ReDistrSign");
error = true;
} else if ((SizeArray=GetArrayParam("SizeArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("SizeArray");
error = true;
} else if ((LowShdWidthArray=GetArrayParam("LowShdWidthArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LowShdWidthArray");
error = true;
} else if ((HiShdWidthArray=GetArrayParam("HiShdWidthArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("HiShdWidthArray");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->SizeArray.resize(rank);
tmp->LowShdWidthArray.resize(rank);
tmp->HiShdWidthArray.resize(rank);
for (int i = 0; i < rank; i++) {
tmp->SizeArray[i] = SizeArray[i];
tmp->LowShdWidthArray[i] = LowShdWidthArray[i];
tmp->HiShdWidthArray[i] = HiShdWidthArray[i];
}
}
delete [] SizeArray;
delete [] LowShdWidthArray;
delete [] HiShdWidthArray;
return tmp;
}
//-------------------------------------------- Get_align_Info ------------------------------------------
align_Info* Get_align_Info(TraceCall& trc_call)
{
bool error = false;
long * AxisArray = NULL;
long * CoeffArray = NULL;
long * ConstArray = NULL;
align_Info* tmp = new align_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("ArrayHeader", tmp->ArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHeader");
error = true;
} else if (!ParamFromStrArr("ArrayHandlePtr", tmp->ArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHandlePtr");
error = true;
} else if(!ParamFromStrArr("PatternRefPtr", tmp->PatternRefPtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PatternRefPtr");
error = true;
} else if(!ParamFromStrArr("PatternRef", tmp->PatternRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PatternRef");
error = true;
} else if ((tmp->PatternType = ModifierFromStrArr(trc_call.call_info, trc_call.call_info_count)) == 0) {
ParamNotFoundErr("(AMView)/(DisArray)");
error = true;
} else if ((AxisArray=GetArrayParam("AxisArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("AxisArray");
error = true;
} else if ((CoeffArray=GetArrayParam("CoeffArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("CoeffArray");
error = true;
} else if ((ConstArray=GetArrayParam("ConstArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("CoeffArray");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
delete [] AxisArray;
delete [] CoeffArray;
delete [] ConstArray;
} else {
tmp->AxisArray.resize(arrayRank);
tmp->CoeffArray.resize(arrayRank);
tmp->ConstArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->AxisArray[i] = AxisArray[i];
tmp->CoeffArray[i] = CoeffArray[i];
tmp->ConstArray[i] = ConstArray[i];
}
delete [] AxisArray;
delete [] CoeffArray;
delete [] ConstArray;
}
return tmp;
}
//-------------------------------------------- Get_realn_Info ------------------------------------------
realn_Info* Get_realn_Info(TraceCall& trc_call)
{
bool error = false;
long * AxisArray = NULL;
long * CoeffArray = NULL;
long * ConstArray = NULL;
realn_Info* tmp = new realn_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("ArrayHeader", tmp->ArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHeader");
error = true;
} else if (!ParamFromStrArr("ArrayHandlePtr", tmp->ArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHandlePtr");
error = true;
} else if(!ParamFromStrArr("PatternRefPtr", tmp->PatternRefPtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PatternRefPtr");
error = true;
} else if(!ParamFromStrArr("PatternRef", tmp->PatternRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PatternRef");
error = true;
} else if ((tmp->PatternType = ModifierFromStrArr(trc_call.call_info, trc_call.call_info_count)) == 0) {
ParamNotFoundErr("(AMView)/(DisArray)");
error = true;
} else if (!ParamFromStrArr("NewSign", tmp->NewSign, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("NewSign");
error = true;
} else if ((AxisArray=GetArrayParam("AxisArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("AxisArray");
error = true;
} else if ((CoeffArray=GetArrayParam("CoeffArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("CoeffArray");
error = true;
} else if ((ConstArray=GetArrayParam("ConstArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("CoeffArray");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->AxisArray.resize(arrayRank);
tmp->CoeffArray.resize(arrayRank);
tmp->ConstArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->AxisArray[i] = AxisArray[i];
tmp->CoeffArray[i] = CoeffArray[i];
tmp->ConstArray[i] = ConstArray[i];
}
}
delete [] AxisArray;
delete [] CoeffArray;
delete [] ConstArray;
return tmp;
}
//-------------------------------------------- Get_arrcpy_Info ------------------------------------------
//
// FromBufferPtr=4be40c; | FromArrayHeader=4bf32c; FromArrayHandlePtr=833750;
// ToBufferPtr=4be38c; | ToArrayHeader=498490; ToArrayHandlePtr=805550;
// CopyRegim=2;
//
// if parameter FromArrayHeader exist:
// [ FromInitIndexArray[0]=-1; FromLastIndexArray[0]=2; FromStepArray[0]=9; ]
//
// if parameter ToArrayHeader exist:
// [ ToInitIndexArray[0]=-1; ToLastIndexArray[0]=0; ToStepArray[0]=1; ]
//-------------------------------------------- Get_arrcpy_Info ------------------------------------------
/*
FromArrayHeader=12ff74;
ToArrayHeader=4ae560;
CopyRegim=0;
FromInitIndexArray[0]=0;
FromInitIndexArray[1]=-1;
FromLastIndexArray[0]=0;
FromLastIndexArray[1]=-1;
FromStepArray[0]=1;
FromStepArray[1]=1;
ToInitIndexArray[0]=-1;
ToLastIndexArray[0]=0;
ToStepArray[0]=1;
FromArrayHeader[],
FromInitIndexArray[],
FromLastIndexArray[],
FromStepArray[],
ToArrayHeader[],
ToInitIndexArray[],
ToLastIndexArray[],
ToStepArray[],
CopyRegimPtr
ret_aarrcp_ TIME=0.00000100 LINE=31 FILE=gauss_c.cdv
Res=11;
*/
arrcpy_Info* Get_arrcpy_Info(TraceCall& trc_call)
{
bool error = false;
bool FromBuffer = false;
long * FromInitIndexArray = NULL;
long * FromLastIndexArray = NULL;
long * FromStepArray = NULL;
long FromRank = 0;
bool ToBuffer = false;
long * ToInitIndexArray = NULL;
long * ToLastIndexArray = NULL;
long * ToStepArray = NULL;
long ToRank = 0;
arrcpy_Info* tmp = new arrcpy_Info;
assert(tmp != NULL);
tmp->FromBufferPtr = 0;
if (ParamFromStrArr("FromBufferPtr", tmp->FromBufferPtr, trc_call.call_info, trc_call.call_info_count, 16)) {
FromBuffer = true;
} else if (ParamFromStrArr("FromArrayHeader", tmp->FromArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
if (!ParamFromStrArr("FromArrayHandlePtr", tmp->FromArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("FromArrayHandlePtr");
error = true;
} else if ((FromInitIndexArray=GetArrayParam("FromInitIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("FromInitIndexArray");
error = true;
} else if ((FromLastIndexArray=GetArrayParam("FromLastIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("FromLastIndexArray");
error = true;
} else if ((FromStepArray=GetArrayParam("FromStepArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("FromStepArray");
error = true;
} else
FromRank = arrayRank;
} else {
ParamNotFoundErr("FromBufferPtr/FromArrayHeader");
error = true;
goto err;
}
tmp->ToBufferPtr = 0;
if (ParamFromStrArr("ToBufferPtr", tmp->ToBufferPtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ToBuffer = true;
} else if (ParamFromStrArr("ToArrayHeader", tmp->ToArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
if (!ParamFromStrArr("ToArrayHandlePtr", tmp->ToArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ToArrayHandlePtr");
error = true;
} else if ((ToInitIndexArray=GetArrayParam("ToInitIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("ToInitIndexArray");
error = true;
} else if ((ToLastIndexArray=GetArrayParam("ToLastIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("ToLastIndexArray");
error = true;
} else if ((ToStepArray=GetArrayParam("ToStepArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("ToStepArray");
error = true;
} else
ToRank = arrayRank;
} else {
ParamNotFoundErr("ToBufferPtr/ToArrayHeader");
error = true;
goto err;
}
if (FromBuffer || ToBuffer) {
if (!ParamFromStrArr("CopyRegim", tmp->CopyRegim, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("CopyRegim");
error = true;
}
tmp->CopyFlagPtr = 0;
}
err:if (error) {
delete tmp;
tmp = NULL;
} else {
if (!FromBuffer) {
tmp->FromInitIndexArray.resize(FromRank);
tmp->FromLastIndexArray.resize(FromRank);
tmp->FromStepArray.resize(FromRank);
for (int i=0; i < FromRank; i++) {
tmp->FromInitIndexArray[i] = FromInitIndexArray[i];
tmp->FromLastIndexArray[i] = FromLastIndexArray[i];
tmp->FromStepArray[i] = FromStepArray[i];
}
}
if (!ToBuffer) {
tmp->ToInitIndexArray.resize(ToRank);
tmp->ToLastIndexArray.resize(ToRank);
tmp->ToStepArray.resize(ToRank);
for (int i=0; i < ToRank; i++) {
tmp->ToInitIndexArray[i] = ToInitIndexArray[i];
tmp->ToLastIndexArray[i] = ToLastIndexArray[i];
tmp->ToStepArray[i] = ToStepArray[i];
}
}
}
delete [] FromInitIndexArray;
delete [] FromLastIndexArray;
delete [] FromStepArray;
delete [] ToInitIndexArray;
delete [] ToLastIndexArray;
delete [] ToStepArray;
// cout << "FromRank = " << FromRank << ", ToRAnk = " << ToRank << endl;
return tmp;
}
arrcpy_Info* Get_aarrcp_Info(TraceCall& trc_call)
{
bool error = false;
bool FromBuffer = false;
long * FromInitIndexArray = NULL;
long * FromLastIndexArray = NULL;
long * FromStepArray = NULL;
long FromRank = 0;
bool ToBuffer = false;
long * ToInitIndexArray = NULL;
long * ToLastIndexArray = NULL;
long * ToStepArray = NULL;
long ToRank = 0;
arrcpy_Info* tmp = new arrcpy_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("CopyFlagPtr", tmp->CopyFlagPtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("CopyFlagPtr");
error = true;
}
tmp->FromBufferPtr = 0;
if (ParamFromStrArr("FromBufferPtr", tmp->FromBufferPtr, trc_call.call_info, trc_call.call_info_count, 16)) {
FromBuffer = true;
} else if (ParamFromStrArr("FromArrayHeader", tmp->FromArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
if (!ParamFromStrArr("FromArrayHandlePtr", tmp->FromArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("FromArrayHandlePtr");
error = true;
} else if ((FromInitIndexArray=GetArrayParam("FromInitIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("FromInitIndexArray");
error = true;
} else if ((FromLastIndexArray=GetArrayParam("FromLastIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("FromLastIndexArray");
error = true;
} else if ((FromStepArray=GetArrayParam("FromStepArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("FromStepArray");
error = true;
} else
FromRank = arrayRank;
} else {
ParamNotFoundErr("FromBufferPtr/FromArrayHeader");
error = true;
goto err;
}
tmp->ToBufferPtr = 0;
if (ParamFromStrArr("ToBufferPtr", tmp->ToBufferPtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ToBuffer = true;
} else if (ParamFromStrArr("ToArrayHeader", tmp->ToArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
if (!ParamFromStrArr("ToArrayHandlePtr", tmp->ToArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ToArrayHandlePtr");
error = true;
} else if ((ToInitIndexArray=GetArrayParam("ToInitIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("ToInitIndexArray");
error = true;
} else if ((ToLastIndexArray=GetArrayParam("ToLastIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("ToLastIndexArray");
error = true;
} else if ((ToStepArray=GetArrayParam("ToStepArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("ToStepArray");
error = true;
} else
ToRank = arrayRank;
} else {
ParamNotFoundErr("ToBufferPtr/ToArrayHeader");
error = true;
goto err;
}
if (FromBuffer || ToBuffer) {
if (!ParamFromStrArr("CopyRegim", tmp->CopyRegim, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("CopyRegim");
error = true;
}
}
err:if (error) {
delete tmp;
tmp = NULL;
} else {
if (!FromBuffer) {
tmp->FromInitIndexArray.resize(FromRank);
tmp->FromLastIndexArray.resize(FromRank);
tmp->FromStepArray.resize(FromRank);
for (int i=0; i < FromRank; i++) {
tmp->FromInitIndexArray[i] = FromInitIndexArray[i];
tmp->FromLastIndexArray[i] = FromLastIndexArray[i];
tmp->FromStepArray[i] = FromStepArray[i];
}
}
if (!ToBuffer) {
tmp->ToInitIndexArray.resize(ToRank);
tmp->ToLastIndexArray.resize(ToRank);
tmp->ToStepArray.resize(ToRank);
for (int i=0; i < ToRank; i++) {
tmp->ToInitIndexArray[i] = ToInitIndexArray[i];
tmp->ToLastIndexArray[i] = ToLastIndexArray[i];
tmp->ToStepArray[i] = ToStepArray[i];
}
}
}
delete [] FromInitIndexArray;
delete [] FromLastIndexArray;
delete [] FromStepArray;
delete [] ToInitIndexArray;
delete [] ToLastIndexArray;
delete [] ToStepArray;
// cout << "FromRank = " << FromRank << ", ToRAnk = " << ToRank << endl;
return tmp;
}
waitcp_Info* Get_waitcp_Info(TraceCall& trc_call)
{
bool error = false;
waitcp_Info* tmp = new waitcp_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("CopyFlagPtr", tmp->CopyFlagPtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("CopyFlagPtr");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
}
return tmp;
}
//-------------------------------------------- Get_crtpl_Info ------------------------------------------
crtpl_Info* Get_crtpl_Info(TraceCall& trc_call)
{
bool error = false;
crtpl_Info* tmp = new crtpl_Info;
assert(tmp != NULL);
if(!ParamFromStrArr("LoopRef", tmp->ID, trc_call.ret_info, trc_call.ret_info_count, 16)) {
ParamNotFoundErr("LoopRef");
error = true;
} else if(!ParamFromStrArr("Rank", tmp->Rank, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("Rank");
error = true;
}
if (error) {
delete tmp;
return NULL;
} else
return tmp;
}
//-------------------------------------------- Get_exfrst_Info ------------------------------------------
exfrst_Info* Get_exfrst_Info(TraceCall& trc_call)
{
bool error = false;
exfrst_Info* tmp = new exfrst_Info;
assert(tmp != NULL);
if(!ParamFromStrArr("LoopRef", tmp->ID, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("LoopRef");
error = true;
} else if(!ParamFromStrArr("ShadowGroupRef", tmp->ShadowGroupRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ShadowGroupRef");
error = true;
}
if (error) {
delete tmp;
return NULL;
} else
return tmp;
}
//-------------------------------------------- Get_across_Info ------------------------------------------
/*
call_across_ TIME=0.00000100 LINE=81 FILE=jacr_3dK.cdv
AcrossType=0;
OldShadowGroupRef=8c5cc0;
NewShadowGroupRef=8c5b50;
PipeLinePar=0;
CondPipeLine=0
ErrPipeLine=30
ret_across_ TIME=0.00000100 LINE=81 FILE=jacr_3dK.cdv
PipeLinePLAxis=0
*/
across_Info* Get_across_Info(TraceCall& trc_call)
{
bool error = false;
across_Info* tmp = new across_Info;
assert(tmp != NULL);
if(!ParamFromStrArr("AcrossType", tmp->AcrossType, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("AcrossType");
error = true;
} else if(!ParamFromStrArr("OldShadowGroupRef", tmp->OldShadowGroupRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("OldShadowGroupRef");
error = true;
} else if(!ParamFromStrArr("NewShadowGroupRef", tmp->NewShadowGroupRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("NewShadowGroupRef");
error = true;
} else if (!ParamFromStrArr("PipeLinePar", tmp->PipeLinePar, trc_call.call_info, trc_call.call_info_count/*, 10*/)) {
ParamNotFoundErr("PipeLinePar");
error = true;
} else if (!ParamFromStrArr("CondPipeLine", tmp->CondPipeLine, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("CondPipeLine");
error = true;
} else if (!ParamFromStrArr("ErrPipeLine", tmp->ErrPipeLine, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("ErrPipeLine");
error = true;
// } else if (!ParamFromStrArr("PipeLinePLAxis", tmp->PipeLinePLAxis, trc_call.ret_info, trc_call.ret_info_count, 10)) {
// ParamNotFoundErr("PipeLinePLAxis");
// error = true;
}
if (error) {
delete tmp;
return NULL;
} else
return tmp;
}
//-------------------------------------------- Get_mappl_Info ------------------------------------------
mappl_Info* Get_mappl_Info(TraceCall& trc_call)
{
bool error = false;
long * AxisArray = NULL;
long * CoeffArray = NULL;
long * ConstArray = NULL;
long * InInitIndexArray = NULL;
long * InLastIndexArray = NULL;
long * InStepArray = NULL;
int axisRank = 0;
int i;
mappl_Info* tmp = new mappl_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("LoopRef", tmp->LoopRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("LoopRef");
error = true;
} else if (!ParamFromStrArr("PatternRefPtr", tmp->PatternRefPtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PatternRefPtr");
error = true;
} else if (!ParamFromStrArr("PatternRef", tmp->PatternRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PatternRef");
error = true;
} else if ((tmp->PatternType = ModifierFromStrArr(trc_call.call_info, trc_call.call_info_count)) == 0) {
ParamNotFoundErr("(AMView)/(DisArray)");
error = true;
} else {
if ((AxisArray=GetArrayParam("AxisArray", trc_call.call_info, trc_call.call_info_count)) != NULL) {
axisRank = arrayRank;
} else {
ParamNotFoundErr("AxisArray");
error = true;
goto err;
}
}
if ((CoeffArray=GetArrayParam("CoeffArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("CoeffArray");
error = true;
} else if ((ConstArray=GetArrayParam("ConstArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("CoeffArray");
error = true;
} else if ((InInitIndexArray=GetArrayParam("InInitIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InInitIndexArray");
error = true;
} else if ((InLastIndexArray=GetArrayParam("InLastIndexArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InLastIndexArray");
error = true;
} else if ((InStepArray=GetArrayParam("InStepArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InStepArray");
error = true;
}
err:
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->AxisArray.resize(axisRank);
tmp->CoeffArray.resize(axisRank);
tmp->ConstArray.resize(axisRank);
tmp->InInitIndexArray.resize(arrayRank);
tmp->InLastIndexArray.resize(arrayRank);
tmp->InStepArray.resize(arrayRank);
for (i=0; i < axisRank; i++) {
tmp->AxisArray[i] = AxisArray[i];
// prot << trc_call.source_line << ": i=" << i << ", AxisArray[i]=" << AxisArray[i] << endl;
tmp->CoeffArray[i] = CoeffArray[i];
tmp->ConstArray[i] = ConstArray[i];
}
for (i=0; i < arrayRank; i++) {
tmp->InInitIndexArray[i] = InInitIndexArray[i];
tmp->InLastIndexArray[i] = InLastIndexArray[i];
tmp->InStepArray[i] = InStepArray[i];
}
}
delete [] AxisArray;
delete [] CoeffArray;
delete [] ConstArray;
delete [] InInitIndexArray;
delete [] InLastIndexArray;
delete [] InStepArray;
return tmp;
}
//---------------Get_dopl_Info----------------------
//grig
dopl_full_Info* Get_dopl_Info(TraceCall& trc_call)
{
bool error = false;
long * AStep=NULL;
long * ALow=NULL;
long * AHigh=NULL;
long * ADim=NULL;
bool thereisDim=false;
long DimRank,HighRank,LowRank,stepRank;
dopl_full_Info* tmp = new dopl_full_Info;
assert(tmp != NULL);
//====
if(!ParamFromStrArr("LoopRef", tmp->ID, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("LoopRef");
error = true;
}
if(!ParamFromStrArr("DoPL", tmp->ReturnVar, trc_call.ret_info, trc_call.ret_info_count, 10)) {
ParamNotFoundErr("DoPL");
error = true;
}
//=***
//was-grig ParamFromStrArr("LoopRef", tmp->ID, trc_call.call_info, trc_call.call_info_count, 16);
//tmp->ID=Get_IDOnlyInfo("LoopRef",trc_call.call_info,trc_call.call_info_count,16);
if(!(ADim=GetArrayParam("Dim",trc_call.call_info,trc_call.call_info_count))==NULL)
{
thereisDim=true;
DimRank=arrayRank;
}
if(thereisDim)
{
ALow=GetArrayParam("Lower",trc_call.call_info,trc_call.call_info_count);
LowRank=arrayRank;
AHigh=GetArrayParam("Upper",trc_call.call_info,trc_call.call_info_count);
HighRank=arrayRank;
AStep=GetArrayParam("Step",trc_call.call_info,trc_call.call_info_count);
stepRank=arrayRank;
}
if(thereisDim)
{
if(DimRank!=LowRank)
{
printf("something wrong with dopl _function - DimRank!=Lowrank\n");
}
tmp->Dim.resize(DimRank);
tmp->Lower.resize(LowRank);
tmp->Upper.resize(HighRank);
tmp->Step.resize(stepRank);
for(int i=0;i<DimRank;i++)
{
tmp->Dim[i]=ADim[i];
tmp->Lower[i]=ALow[i];
tmp->Upper[i]=AHigh[i];
tmp->Step[i]=AStep[i];
}
}
return tmp;
}
//\grig
//-------------------------------------------- Get_crtred_Info ------------------------------------------
crtred_Info* Get_crtred_Info(TraceCall& trc_call)
{
bool error = false;
crtred_Info* tmp = new crtred_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("RedRef", tmp->ID, trc_call.ret_info, trc_call.ret_info_count, 16)) {
ParamNotFoundErr("RedRef");
error = true;
} else if (!ParamFromStrArr("RedArrayType", tmp->RedArrayType, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("RedArrayType");
error = true;
} else if (!ParamFromStrArr("RedArrayLength", tmp->RedArrayLength, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("RedArrayLength");
error = true;
} else if (!ParamFromStrArr("LocElmLength", tmp->LocElmLength, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("LocElmLength");
error = true;
}
if (error) {
delete tmp;
return NULL;
} else
return tmp;
}
//-------------------------------------------- Get_insred_Info ------------------------------------------
insred_Info* Get_insred_Info(TraceCall& trc_call)
{
bool error = false;
insred_Info* tmp = new insred_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("RedGroupRef", tmp->RG_ID, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("RedGroupRef");
error = true;
} else if (!ParamFromStrArr("RedRef", tmp->RV_ID, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("RedRef");
error = true;
}
if (error) {
delete tmp;
return NULL;
} else
return tmp;
}
//------------------------------------------- Get_crtshg_Info ------------------------------------------
crtshg_Info* Get_crtshg_Info(TraceCall& trc_call)
{
bool error = false;
crtshg_Info* tmp = new crtshg_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("StaticSign", tmp->StaticSign, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("StaticSign");
error = true;
} else if (!ParamFromStrArr("ShadowGroupRef", tmp->ShadowGroupRef, trc_call.ret_info, trc_call.ret_info_count, 16)) {
ParamNotFoundErr("ShadowGroupRef");
error = true;
}
if (error) {
delete tmp;
return NULL;
} else
return tmp;
}
//-------------------------------------------- Get_inssh_Info ------------------------------------------
inssh_Info* Get_inssh_Info(TraceCall& trc_call)
{
bool error = false;
long* LowShdWidthArray = NULL;
long* HiShdWidthArray = NULL;
inssh_Info* tmp = new inssh_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("ShadowGroupRef", tmp->ShadowGroupRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ShadowGroupRef");
error = true;
} else if (!ParamFromStrArr("ArrayHeader", tmp->ArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHeader");
error = true;
} else if (!ParamFromStrArr("ArrayHandlePtr", tmp->ArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHandlePtr");
error = true;
} else if (!ParamFromStrArr("FullShdSign", tmp->FullShdSign, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("FullShdSign");
error = true;
} else if ((LowShdWidthArray=GetArrayParam("LowShdWidthArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LowShdWidthArray");
error = true;
} else if ((HiShdWidthArray=GetArrayParam("HiShdWidthArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("HiShdWidthArray");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->LowShdWidthArray.resize(arrayRank);
tmp->HiShdWidthArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
//====
// ShdWid[i]=abs(LowShdWidthArray[i]);//<HiShdWidthArray[i])?HiShdWidthArray[i]:LowShdWidthArray[i];
//=***
tmp->LowShdWidthArray[i] = LowShdWidthArray[i];
tmp->HiShdWidthArray[i] = HiShdWidthArray[i];
//====
//printf("tmp->LowShdWidthArray[i]=%d tmp->HiShdWidthArray[i]=%d\n",tmp->LowShdWidthArray[i],tmp->HiShdWidthArray[i]);
//printf("ShdWid[%d]=%d\n",i,ShdWid[i]);
//=***
}
}
delete [] LowShdWidthArray;
delete [] HiShdWidthArray;
tmp->func = inssh_;
return tmp;
}
//-------------------------------------------- Get_insshd_Info -----------------------------------------
inssh_Info* Get_insshd_Info(TraceCall& trc_call)
{
bool error = false;
long* LowShdWidthArray = NULL;
long* HiShdWidthArray = NULL;
long* ShdSignArray = NULL;
inssh_Info* tmp = new inssh_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("ShadowGroupRef", tmp->ShadowGroupRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ShadowGroupRef");
error = true;
} else if (!ParamFromStrArr("ArrayHeader", tmp->ArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHeader");
error = true;
} else if (!ParamFromStrArr("ArrayHandlePtr", tmp->ArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHandlePtr");
error = true;
} else if (!ParamFromStrArr("MaxShdCount", tmp->MaxShdCount, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("MaxShdCount");
error = true;
} else if ((LowShdWidthArray=GetArrayParam("LowShdWidthArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LowShdWidthArray");
error = true;
} else if ((HiShdWidthArray=GetArrayParam("HiShdWidthArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("HiShdWidthArray");
error = true;
} else if ((ShdSignArray=GetArrayParam("ShdSignArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("ShdSignArray");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->LowShdWidthArray.resize(arrayRank);
tmp->HiShdWidthArray.resize(arrayRank);
tmp->ShdSignArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->LowShdWidthArray[i] = LowShdWidthArray[i];
tmp->HiShdWidthArray[i] = HiShdWidthArray[i];
tmp->ShdSignArray[i] = ShdSignArray[i];
}
}
delete [] LowShdWidthArray;
delete [] HiShdWidthArray;
delete [] ShdSignArray;
tmp->func = insshd_;
return tmp;
}
//-------------------------------------------- Get_incsh_Info ------------------------------------------
inssh_Info* Get_incsh_Info(TraceCall& trc_call)
{
bool error = false;
long* InitDimIndex = NULL;
long* LastDimIndex = NULL;
long* InitLowShdIndex = NULL;
long* LastLowShdIndex = NULL;
long* InitHiShdIndex = NULL;
long* LastHiShdIndex = NULL;
inssh_Info* tmp = new inssh_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("ShadowGroupRef", tmp->ShadowGroupRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ShadowGroupRef");
error = true;
} else if (!ParamFromStrArr("ArrayHeader", tmp->ArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHeader");
error = true;
} else if (!ParamFromStrArr("ArrayHandlePtr", tmp->ArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHandlePtr");
error = true;
} else if (!ParamFromStrArr("FullShdSign", tmp->FullShdSign, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("FullShdSign");
error = true;
} else if ((InitDimIndex=GetArrayParam("InitDimIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InitDimIndex");
error = true;
} else if ((LastDimIndex=GetArrayParam("LastDimIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LastDimIndex");
error = true;
} else if ((InitLowShdIndex=GetArrayParam("InitLowShdIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InitLowShdIndex");
error = true;
} else if ((LastLowShdIndex=GetArrayParam("LastLowShdIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LastLowShdIndex");
error = true;
} else if ((InitHiShdIndex=GetArrayParam("InitHiShdIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InitHiShdIndex");
error = true;
} else if ((LastHiShdIndex=GetArrayParam("LastHiShdIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LastHiShdIndex");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->InitDimIndex.resize(arrayRank);
tmp->LastDimIndex.resize(arrayRank);
tmp->InitLowShdIndex.resize(arrayRank);
tmp->LastLowShdIndex.resize(arrayRank);
tmp->InitHiShdIndex.resize(arrayRank);
tmp->LastHiShdIndex.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->InitDimIndex[i] = InitDimIndex[i];
tmp->LastDimIndex[i] = LastDimIndex[i];
tmp->InitLowShdIndex[i] = InitLowShdIndex[i];
tmp->LastLowShdIndex[i] = LastLowShdIndex[i];
tmp->InitHiShdIndex[i] = InitHiShdIndex[i];
tmp->LastHiShdIndex[i] = LastHiShdIndex[i];
}
}
delete [] InitDimIndex;
delete [] LastDimIndex;
delete [] InitLowShdIndex;
delete [] LastLowShdIndex;
delete [] InitHiShdIndex;
delete [] LastHiShdIndex;
tmp->func = incsh_;
return tmp;
}
//-------------------------------------------- Get_incshd_Info -----------------------------------------
inssh_Info* Get_incshd_Info(TraceCall& trc_call)
{
bool error = false;
long* ShdSignArray = NULL;
long* InitDimIndex = NULL;
long* LastDimIndex = NULL;
long* InitLowShdIndex = NULL;
long* LastLowShdIndex = NULL;
long* InitHiShdIndex = NULL;
long* LastHiShdIndex = NULL;
inssh_Info* tmp = new inssh_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("ShadowGroupRef", tmp->ShadowGroupRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ShadowGroupRef");
error = true;
} else if (!ParamFromStrArr("ArrayHeader", tmp->ArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHeader");
error = true;
} else if (!ParamFromStrArr("ArrayHandlePtr", tmp->ArrayHandlePtr, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("ArrayHandlePtr");
error = true;
} else if (!ParamFromStrArr("MaxShdCount", tmp->MaxShdCount, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("MaxShdCount");
error = true;
} else if ((InitDimIndex=GetArrayParam("InitDimIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InitDimIndex");
error = true;
} else if ((LastDimIndex=GetArrayParam("LastDimIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LastDimIndex");
error = true;
} else if ((InitLowShdIndex=GetArrayParam("InitLowShdIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InitLowShdIndex");
error = true;
} else if ((LastLowShdIndex=GetArrayParam("LastLowShdIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LastLowShdIndex");
error = true;
} else if ((InitHiShdIndex=GetArrayParam("InitHiShdIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("InitHiShdIndex");
error = true;
} else if ((LastHiShdIndex=GetArrayParam("LastHiShdIndex", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LastHiShdIndex");
error = true;
} else if ((ShdSignArray=GetArrayParam("ShdSignArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("ShdSignArray");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->InitDimIndex.resize(arrayRank);
tmp->LastDimIndex.resize(arrayRank);
tmp->InitLowShdIndex.resize(arrayRank);
tmp->LastLowShdIndex.resize(arrayRank);
tmp->InitHiShdIndex.resize(arrayRank);
tmp->LastHiShdIndex.resize(arrayRank);
tmp->ShdSignArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->InitDimIndex[i] = InitDimIndex[i];
tmp->LastDimIndex[i] = LastDimIndex[i];
tmp->InitLowShdIndex[i] = InitLowShdIndex[i];
tmp->LastLowShdIndex[i] = LastLowShdIndex[i];
tmp->InitHiShdIndex[i] = InitHiShdIndex[i];
tmp->LastHiShdIndex[i] = LastHiShdIndex[i];
tmp->ShdSignArray[i] = ShdSignArray[i];
}
}
delete [] InitDimIndex;
delete [] LastDimIndex;
delete [] InitLowShdIndex;
delete [] LastLowShdIndex;
delete [] InitHiShdIndex;
delete [] LastHiShdIndex;
delete [] ShdSignArray;
tmp->func = incshd_;
return tmp;
}
//----------------------------------------- Get_crtrbp_Info ---------------------------------------
crtrbp_Info * Get_crtrbp_Info(TraceCall& trc_call)
{
bool error = false;
long* coordArray = NULL;
crtrbp_Info* tmp = new crtrbp_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("RemArrayHeader", tmp->RemArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("RemArrayHeader");
error = true;
} else if (!ParamFromStrArr("BufferHeader", tmp->ID, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("BufferHeader");
error = true;
} else if (!ParamFromStrArr("StaticSign", tmp->StaticSign, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("StaticSign");
error = true;
} else if (!ParamFromStrArr("PSRef", tmp->PSRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("PSRef");
error = true;
} else if ((coordArray=GetArrayParam("CoordArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("CoordArray");
error = true;
} else if (!ParamFromStrArr("IsLocal", tmp->IsLocal, trc_call.ret_info, trc_call.ret_info_count, 10)) {
ParamNotFoundErr("IsLocal");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->CoordArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->CoordArray[i] = coordArray[i];
}
}
delete [] coordArray;
return tmp;
}
//----------------------------------------- Get_crtrbl_Info ---------------------------------------
crtrbl_Info * Get_crtrbl_Info(TraceCall& trc_call)
{
bool error = false;
long* AxisArray = NULL;
long* CoeffArray = NULL;
long* ConstArray = NULL;
crtrbl_Info* tmp = new crtrbl_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("RemArrayHeader", tmp->RemArrayHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("RemArrayHeader");
error = true;
} else if (!ParamFromStrArr("BufferHeader", tmp->BufferHeader, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("BufferHeader");
error = true;
} else if (!ParamFromStrArr("StaticSign", tmp->StaticSign, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("StaticSign");
error = true;
} else if (!ParamFromStrArr("LoopRef", tmp->LoopRef, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("LoopRef");
error = true;
} else if ((AxisArray=GetArrayParam("AxisArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("AxisArray");
error = true;
} else if ((CoeffArray=GetArrayParam("CoeffArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("CoeffArray");
error = true;
} else if ((ConstArray=GetArrayParam("ConstArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("ConstArray");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->AxisArray.resize(arrayRank);
tmp->CoeffArray.resize(arrayRank);
tmp->ConstArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->AxisArray[i] = AxisArray[i];
tmp->CoeffArray[i] = CoeffArray[i];
tmp->ConstArray[i] = ConstArray[i];
}
}
delete [] AxisArray;
delete [] CoeffArray;
delete [] ConstArray;
return tmp;
}
//----------------------------------------- Get_loadrb_Info ---------------------------------------
loadrb_Info * Get_loadrb_Info(TraceCall& trc_call)
{
bool error = false;
loadrb_Info* tmp = new loadrb_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("BufferHeader", tmp->ID, trc_call.call_info, trc_call.call_info_count, 16)) {
ParamNotFoundErr("BufferHeader");
error = true;
} else if (!ParamFromStrArr("RenewSign", tmp->RenewSign, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("RenewSign");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
}
return tmp;
}
srmem_Info * Get_srmem_Info(TraceCall& trc_call)
{
bool error = false;
long* lengthArray = NULL;
srmem_Info* tmp = new srmem_Info;
assert(tmp != NULL);
if (!ParamFromStrArr("MemoryCount", tmp->MemoryCount, trc_call.call_info, trc_call.call_info_count, 10)) {
ParamNotFoundErr("MemoryCount");
error = true;
} else if ((lengthArray=GetArrayParam("LengthArray", trc_call.call_info, trc_call.call_info_count)) == NULL) {
ParamNotFoundErr("LengthArray");
error = true;
}
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->LengthArray.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->LengthArray[i] = lengthArray[i];
}
}
delete [] lengthArray;
return tmp;
}
//----------------------------------------- Service routines ---------------------------------------
root_Info* Get_Root_Info()
{
bool error = false;
unsigned long* VPSSize = NULL;
/* traceLines */
root_Info* tmp = new root_Info;
assert(tmp != NULL);
if (strcmp(traceLines->p_lines[0], RTS_VERSION) != 0) {
cerr << " NEEDED " << RTS_VERSION << endl;
prot << " NEEDED " << RTS_VERSION << endl;
//grig!!!!
//abort();
//\grig
}
if (!ParamFromStrArr("ProcCount", TraceProcNum, traceLines->p_lines, traceLines->p_size, 10)) {
// ParamNotFoundErr("ProcCount");
// error = true;
}
if (!ParamFromStrArr("VProcCount", tmp->VProcCount, traceLines->p_lines,
traceLines->p_size, 10)) {
ParamNotFoundErr("VProcCount");
error = true;
}
if (tmp->VProcCount != 0) {
if (!ParamFromStrArr("VPSRank", tmp->VPSRank, traceLines->p_lines, traceLines->p_size, 10)) {
ParamNotFoundErr("VPSRank");
error = true;
} else if ((VPSSize=GetVectorParam("VPSSize", traceLines->p_lines, traceLines->p_size)) == NULL) {
ParamNotFoundErr("VPSSize");
error = true;
}
}
/*my grig
if (error) {
delete tmp;
tmp = NULL;
} else {
tmp->VPSSize.resize(arrayRank);
for (int i=0; i < arrayRank; i++) {
tmp->VPSSize[i] = VPSSize[i];
}
}
*/
delete [] VPSSize;
return tmp;
}
//----------------------------------------- Service routines ---------------------------------------
long* GetArrayParam(char* param_name, char** str_list, int str_count)
{
long* arr_param=NULL;
long tmp;
int i=0;
arrayRank = 0;
/* printf("in get array param serching '%s'\n",param_name);
for(int ii=0;ii<str_count;ii++)
{
printf("str_list[%d] = %s \n",ii,str_list[ii]);
}*/
while (IndexParamFromStrArr(param_name, i++, tmp, str_list, str_count, 10)) {
arr_param = (long*)realloc(arr_param,i*sizeof(long));
arrayRank++;
assert(arr_param != NULL);
arr_param[i-1]=tmp;
}
return arr_param;
}
//grig
double* GetArrayParamD(char* param_name, char** str_list, int str_count)
{
double* arr_param=NULL;
double tmp;
int i=0;
arrayRank = 0;
while (IndexParamFromStrArr(param_name, i++, tmp, str_list, str_count)) {
arr_param = (double*)realloc(arr_param,i*sizeof(double));
arrayRank++;
assert(arr_param != NULL);
arr_param[i-1]=tmp;
}
return arr_param;
}
//\grig
int ParamFromString1(char * par_name, char* par_val, char* str)
{
char* pos;
int len;
// prot << "par_name=" << par_name << " par_val=" << par_val << endl;
if (str==NULL)
return 0;
pos = strstr(str,par_name);
if(pos==NULL)
return 0;
pos += strlen(par_name);
len=strcspn(++pos,";");
strncpy(par_val,pos,len);
par_val[len]='\0';
return 1;
}
int ParamFromStrArr1(char * par_name, char*& par_val, char** str_arr, int str_cnt)
{ int i;
int res = 0;
if(str_cnt<=0) return 0;
for(i=0; i<str_cnt; i++)
if ((res=ParamFromString1(par_name, par_val, str_arr[i])) != 0) break;
return res;
};
unsigned long* GetVectorParam(char* param_name, char** str_list, int str_count)
{
unsigned long* arr_param = NULL;
char *buffer = new char[256];
// char *str = buffer;
arrayRank = 0;
if (ParamFromStrArr1(param_name, buffer, str_list, str_count) == 0)
return NULL;
do {
while (buffer[0] == ' ')
buffer++;
arrayRank++;
arr_param = (unsigned long*)realloc(arr_param,arrayRank * sizeof(unsigned long));
assert(arr_param != NULL);
arr_param[arrayRank-1] = strtoul(buffer, &buffer, 10);;
} while (strlen(buffer) != 0);
return arr_param;
}
//-------------------------------------------- Main switch ------------------------------------------
extern Event global_func_id;
extern int global_source_line;
extern char* global_source_file;
bool GetCallParams(TraceCall& trc_call, void*& params)
{
global_func_id = trc_call.func_id;
global_source_line = trc_call.source_line;
global_source_file = trc_call.source_file;
switch(trc_call.func_id) {
// Interval info
case binter_ :
case bsloop_ :
case bploop_ :
return (params = (void*)Get_binter_Info(trc_call)) != NULL;
case einter_ :
case eloop_ :
return (params = (void*)Get_IDOnlyInfo("nline",trc_call.call_info,trc_call.call_info_count,10)) != NULL;
// IO info
case srmem_:
return (params = (void*)Get_srmem_Info(trc_call)) != NULL;
// MPS/AM/AMV info
case crtps_ :
return (params = (void*)Get_crtps_Info(trc_call)) != NULL;
case psview_ :
return (params = (void*)Get_psview_Info(trc_call)) != NULL;
case getps_ :
return (params = (void*)Get_getps_Info(trc_call)) != NULL;
case delps_ :
return (params = (void*)Get_IDOnlyInfo("PSRef",trc_call.call_info,trc_call.call_info_count,16)) != NULL;
case setelw_ :
return (params = (void*)Get_setelw_Info(trc_call)) != NULL;
case getam_ :
return (params = (void*)Get_IDOnlyInfo("AMRef",trc_call.ret_info,trc_call.ret_info_count,16)) != NULL;
case getamr_ :
return (params = (void*)Get_getamr_Info(trc_call)) != NULL;
case runam_ :
return (params = (void*)Get_IDOnlyInfo("AMRef",trc_call.call_info,trc_call.call_info_count,16)) != NULL;
case crtamv_:
return (params = (void*)Get_crtamv_Info(trc_call)) != NULL;
case getamv_ :
return (params = (void*)Get_getamv_Info(trc_call)) != NULL;
case mapam_ :
return (params = (void*)Get_mapam_Info(trc_call)) != NULL;
case delamv_ :
return (params = (void*)Get_IDOnlyInfo("AMViewRef",trc_call.call_info,trc_call.call_info_count,16)) != NULL;
//====
case blkdiv_ :
return (params = (void*)Get_blkdiv_Info(trc_call)) != NULL;
//=***
case distr_ :
return (params = (void*)Get_distr_Info(trc_call)) != NULL;
case redis_ :
return (params = (void*)Get_redis_Info(trc_call)) != NULL;
// DisArray info
case crtda_ :
return (params = (void*)Get_crtda_Info(trc_call)) != NULL;
case align_ :
return (params = (void*)Get_align_Info(trc_call)) != NULL;
case realn_ :
return (params = (void*)Get_realn_Info(trc_call)) != NULL;
case delda_ :
return (params = (void*)Get_IDOnlyInfo("ArrayHeader",trc_call.call_info,trc_call.call_info_count,16)) != NULL;
case arrcpy_ :
return (params = (void*)Get_arrcpy_Info(trc_call)) != NULL;
case aarrcp_ :
return (params = (void*)Get_aarrcp_Info(trc_call)) != NULL;
case waitcp_ :
return (params = (void*)Get_waitcp_Info(trc_call)) != NULL;
// ParLoop info
case crtpl_ :
return (params = (void*)Get_crtpl_Info(trc_call)) != NULL;
case mappl_ :
return (params = (void*)Get_mappl_Info(trc_call)) != NULL;
case dopl_ :
return (params = (void*)Get_dopl_Info(trc_call)) != NULL;
case endpl_ :
return (params = (void*)Get_IDOnlyInfo("LoopRef",trc_call.call_info,trc_call.call_info_count,16)) != NULL;
// Reduction info
case crtrg_ :
return (params = (void*)Get_IDOnlyInfo("RedGroupRef",trc_call.ret_info,trc_call.ret_info_count,16)) != NULL;
case crtred_ :
return (params = (void*)Get_crtred_Info(trc_call)) != NULL;
case insred_ :
return (params = (void*)Get_insred_Info(trc_call)) != NULL;
case strtrd_ :
case waitrd_ :
case delrg_ :
return (params = (void*)Get_IDOnlyInfo("RedGroupRef",trc_call.call_info,trc_call.call_info_count,16)) != NULL;
case delred_ :
return (params = (void*)Get_IDOnlyInfo("RedRef",trc_call.call_info,trc_call.call_info_count,16)) != NULL;
// Shadow info
case crtshg_ :
return (params = (void*)Get_crtshg_Info(trc_call)) != NULL;
case inssh_ :
return (params = (void*)Get_inssh_Info(trc_call)) != NULL;
case insshd_ :
return (params = (void*)Get_insshd_Info(trc_call)) != NULL;
case incsh_ :
return (params = (void*)Get_incsh_Info(trc_call)) != NULL;
case incshd_ :
return (params = (void*)Get_incshd_Info(trc_call)) != NULL;
case delshg_ :
case strtsh_ :
case waitsh_ :
case sendsh_ :
case recvsh_ :
return (params = (void*)Get_IDOnlyInfo("ShadowGroupRef",trc_call.call_info,trc_call.call_info_count,16)) != NULL;
case exfrst_ :
case imlast_ :
return (params = (void*)Get_exfrst_Info(trc_call)) != NULL;
case across_:
return (params = (void *) Get_across_Info(trc_call)) != NULL;
// Remote access info
case crtrbp_ :
return (params = (void*)Get_crtrbp_Info(trc_call)) != NULL;
case crtrbl_ :
return (params = (void*)Get_crtrbl_Info(trc_call)) != NULL;
case loadrb_ :
return (params = (void*)Get_loadrb_Info(trc_call)) != NULL;
case waitrb_ :
return (params = (void*)Get_IDOnlyInfo("BufferHeader",trc_call.call_info,trc_call.call_info_count,16)) != NULL;
default :
return true;
}
}
//-------------------------------------------- FreeCallParams ------------------------------------------
#ifdef nodef
void FreeCallParams(FuncCall& func_call)
{
if (func_call.call_params == NULL)
return;
switch(func_call.func_id) {
// Interval info
case binter_ :
case bsloop_ :
case bploop_ :
free(((binter_Info*)func_call.call_params)->file);
break;
case crtamv_:
// free(((crtamv_Info*)func_call.call_params)->SizeArray);
break;
case distr_ :
// free(((distr_Info*)func_call.call_params)->AxisArray);
// free(((distr_Info*)func_call.call_params)->DistrParamArray);
break;
case redis_ :
// free(((redis_Info*)func_call.call_params)->AxisArray);
// free(((redis_Info*)func_call.call_params)->DistrParamArray);
break;
// DisArray info
case crtda_ :
// free(((crtda_Info*)func_call.call_params)->SizeArray);
break;
case align_ :
// free(((align_Info*)func_call.call_params)->AxisArray);
// free(((align_Info*)func_call.call_params)->CoeffArray);
// free(((align_Info*)func_call.call_params)->ConstArray);
break;
case realn_ :
// free(((realn_Info*)func_call.call_params)->AxisArray);
// free(((realn_Info*)func_call.call_params)->CoeffArray);
// free(((realn_Info*)func_call.call_params)->ConstArray);
break;
case aarrcp_ :
// free(((aarrcp_Info*)func_call.call_params)->FromInitIndexArray);
// free(((aarrcp_Info*)func_call.call_params)->FromLastIndexArray);
// free(((aarrcp_Info*)func_call.call_params)->FromStepArray);
// free(((aarrcp_Info*)func_call.call_params)->ToInitIndexArray);
// free(((aarrcp_Info*)func_call.call_params)->ToLastIndexArray);
// free(((aarrcp_Info*)func_call.call_params)->ToStepArray);
break;
// ParLoop info
case mappl_ :
// free(((mappl_Info*)func_call.call_params)->AxisArray);
// free(((mappl_Info*)func_call.call_params)->CoeffArray);
// free(((mappl_Info*)func_call.call_params)->ConstArray);
// free(((mappl_Info*)func_call.call_params)->InInitIndexArray);
// free(((mappl_Info*)func_call.call_params)->InLastIndexArray);
// free(((mappl_Info*)func_call.call_params)->InStepArray);
break;
// Shadow info
case inssh_ :
// free(((inssh_Info*)func_call.call_params)->LowShdWidthArray);
// free(((inssh_Info*)func_call.call_params)->HiShdWidthArray);
break;
case exfrst_ :
case imlast_ :
break;
}
// free(func_call.call_params);
// func_call.call_params=NULL;
}
#endif
Reference in New Issue Copy Permalink