Alexander_KS/SAPFOR
4
2
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

code refactoring

Browse Source
This commit is contained in:
ALEXks
2024-02-20 11:12:00 +03:00
parent 3221934db8
commit 8402f8c7e9
24 changed files with 1623 additions and 1174 deletions
Download Patch File Download Diff File Expand all files Collapse all files

350
dvm/fdvm/trunk/fdvm/acc.cpp
View File

@@ -655,6 +655,26 @@ SgSymbol *HostProcSymbol(SgStatement *st_do)
return(s);
}
SgSymbol *HostAcrossProcSymbol(SgSymbol *sHostProc, int dependency)
{
SgSymbol *s;
char *sname = (char *)malloc((unsigned)(strlen(sHostProc->identifier())) + 5);
sprintf(sname, "%s_%d", sHostProc->identifier(), dependency);
s = new SgSymbol(PROCEDURE_NAME, sname, *current_file->firstStatement());
acc_func_list = AddToSymbList(acc_func_list, s);
return(s);
}
SgSymbol *HostProcSymbol_RA(SgSymbol *sHostProc)
{
SgSymbol *s;
char *sname = (char *)malloc((unsigned)(strlen(sHostProc->identifier())) + 4);
sprintf(sname, "%s_%s", sHostProc->identifier(), "RA");
s = new SgSymbol(PROCEDURE_NAME, sname, *current_file->firstStatement());
acc_func_list = AddToSymbList(acc_func_list, s);
return(s);
}
SgSymbol *IndirectFunctionSymbol(SgStatement *stmt, char *name)
{
char *sname = (char *)malloc((unsigned)(strlen(stmt->fileName())) + 40);
@@ -675,15 +695,6 @@ SgSymbol *GPUModuleSymb(SgStatement *global_st)
return(mod_symb);
}
SgSymbol *HostAcrossProcSymbol(SgSymbol *sHostProc, int dependency)
{
SgSymbol *s;
char *sname = (char *)malloc((unsigned)(strlen(sHostProc->identifier())) + 5);
sprintf(sname, "%s_%d", sHostProc->identifier(), dependency);
s = new SgSymbol(PROCEDURE_NAME, sname, *current_file->firstStatement());
acc_func_list = AddToSymbList(acc_func_list, s);
return(s);
}
SgSymbol *CudaforSymb(SgStatement *global_st)
{
@@ -2545,7 +2556,7 @@ void ACC_ParallelLoopEnd(SgStatement *pardo)
// creating host-handler for loop anyway
if (!WithAcrossClause())
Create_Host_Loop_Subroutine(hostproc_symb, 0);
Create_Host_Loop_Subroutine_Main(hostproc_symb);
else
{
Create_Host_Across_Loop_Subroutine(hostproc_symb);
@@ -2714,8 +2725,8 @@ void ACC_CreateParallelLoop(int ipl, SgStatement *first_do, int nloop, SgStateme
number_of_loop_line = first_do->lineNumber();
// creating buffers for remote_access references (after creating GPU module)
if (rma && !rma->rmout && !rma->rml->symbol()) // there is synchronous REMOTE_ACCESS clause in PARALLEL directive
CreateRemoteAccessBuffers();
//if (rma && !rma->rmout && !rma->rml->symbol()) // there is synchronous REMOTE_ACCESS clause in PARALLEL directive
CreateRemoteAccessBuffersUp();
if (cur_region)
{
// is first loop of compute region
@@ -2785,7 +2796,7 @@ SgStatement *ACC_CreateStatementGroup(SgStatement *first_st)
// Generating statements for block (sequence) in source program unit
cur_st = first_st->lexPrev();//last_st;
//doStatementsInSourceProgramUnit(first_st, 0, NULL, NULL, adapter_symb, hostproc_symb, 0, NULL, NULL, NULL, NULL);
doStatementsToPerformByHandler(CreateLoopForSequence(first_st),adapter_symb, hostproc_symb, 0, 1);
doStatementsToPerformByHandler(CreateLoopForSequence(first_st),adapter_symb, hostproc_symb, 0, parloop_by_handler);
st_end = cur_st;
// ---------------------------------------------------
if ((cur_region->targets & CUDA_DEVICE)) //if(targets[CUDA])
@@ -3238,12 +3249,13 @@ void ACC_ReductionVarsAreActual()
}
}
void CreateRemoteAccessBuffers()
void CreateRemoteAccessBuffers(SgExpression *rml, int pl_flag)
{
SgExpression *el;
rem_var *remv;
coeffs *scoef;
for (el = rma->rml; el; el = el->rhs())
int interface = parloop_by_handler == 2 && WhatInterface(dvm_parallel_dir) == 2 ? 2 : 1;
for (el = rml; el; el = el->rhs())
{
remv = (rem_var *)(el->lhs())->attributeValue(0, REMOTE_VARIABLE);
if(!remv) continue; // error case: illegal reference in REMOTE_ACCESS directive/clause
@@ -3254,10 +3266,28 @@ void CreateRemoteAccessBuffers()
// scoef = BufferCoeffs(remv->buffer,el->lhs()->symbol());
// adding the attribute (ARRAY_COEF) to buffer symbol
remv->buffer->addAttribute(ARRAY_COEF, (void*)scoef, sizeof(coeffs));
if (pl_flag && interface == 2)
remv->buffer->addAttribute(REMOTE_ACCESS_BUF, (void*)1, 0);
}
return;
}
void CreateRemoteAccessBuffersUp()
{
rem_acc *r;
//looking through the remote-access directive/clause list
for (r=rma; r; r=r->next)
{
//if (r->rml->symbol()) // asynchronous REMOTE_ACCESS clause/directive
// continue;
if (!r->rmout) // REMOTE_ACCESS clause in PARALLEL directive
CreateRemoteAccessBuffers(r->rml, 1);
else
CreateRemoteAccessBuffers(r->rml, 0);
}
return;
}
SgSymbol *CreateReplicatedArray(SgSymbol *s)
{
SgSymbol *ar;
@@ -3508,16 +3538,19 @@ SgExpression *RemoteAccessHeaderList()
{
SgExpression *el, *l, *rma_list;
rem_var *remv;
rem_acc *r;
rma_list = NULL;
if (rma && !rma->rmout && !rma->rml->symbol()) // there is synchronous REMOTE_ACCESS clause in PARALLEL directive
for (el = rma->rml; el; el = el->rhs())
for (r=rma; r; r=r->next)
{
remv = (rem_var *)(el->lhs())->attributeValue(0, REMOTE_VARIABLE);
if(!remv) continue; // error case: illegal reference in REMOTE_ACCESS directive/clause
l = new SgExprListExp(*DVM000(remv->index));
l->setRhs(rma_list);
rma_list = l;
//rma_list = AddListToList(rma_list, l );
for (el = r->rml; el; el = el->rhs())
{
remv = (rem_var *)(el->lhs())->attributeValue(0, REMOTE_VARIABLE);
if(!remv) continue; // error case: illegal reference in REMOTE_ACCESS directive/clause
l = new SgExprListExp(*DVM000(remv->index));
l->setRhs(rma_list);
rma_list = l;
//rma_list = AddListToList(rma_list, l );
}
}
return(rma_list);
}
@@ -3526,13 +3559,21 @@ void AddRemoteAccessBufferList_ToArrayList()
{
SgExpression *el;
rem_var *remv;
if (rma && !rma->rmout && !rma->rml->symbol()) // there is synchronous REMOTE_ACCESS clause in PARALLEL directive
for (el = rma->rml; el; el = el->rhs())
rem_acc *r;
//looking through the remote-access directive/clause list
for (r=rma; r; r=r->next)
{
remv = (rem_var *)(el->lhs())->attributeValue(0, REMOTE_VARIABLE);
if(!remv) continue; // error case: illegal reference in REMOTE_ACCESS directive/clause
acc_array_list = AddNewToSymbList(acc_array_list, remv->buffer);
//if (r->rml->symbol()) // asynchronous REMOTE_ACCESS clause/directive
// continue;
for (el = r->rml; el; el = el->rhs())
{
remv = (rem_var *)(el->lhs())->attributeValue(0, REMOTE_VARIABLE);
if (remv && remv->buffer)
acc_array_list = AddNewToSymbList(acc_array_list, remv->buffer);
}
}
return;
}
@@ -3570,13 +3611,15 @@ SgExpression *BaseArgumentList()
{
symb_list *sl, *array_list;
SgExpression *el, *l, *base_list = NULL;
rem_acc *r;
// create memory base list
array_list = NULL;
// create remote_access objects list
if (rma && !rma->rmout && !rma->rml->symbol()) // there is synchronous REMOTE_ACCESS clause in PARALLEL directive
for (el = rma->rml; el; el = el->rhs())
array_list = AddToSymbList(array_list, el->lhs()->symbol());
for (r=rma; r; r=r->next)
{
for (el = r->rml; el; el = el->rhs())
array_list = AddToSymbList(array_list, el->lhs()->symbol());
}
if (array_list)
{
base_list = ElementOfBaseList(NULL, array_list->symb);
@@ -3633,7 +3676,7 @@ SgExpression *AddrArgumentList()
symb_list *sl;
SgExpression *el, *l, *addr_list = NULL, *ae, *rem_list = NULL;
rem_var *remv;
rem_acc *r;
// create array address list
if (acc_array_list)
{
@@ -3647,17 +3690,25 @@ SgExpression *AddrArgumentList()
}
}
// create remote_access buffer address list and add it to addr_list
if (rma && !rma->rmout && !rma->rml->symbol()) // there is synchronous REMOTE_ACCESS clause in PARALLEL directive
for (el = rma->rml; el; el = el->rhs())
//looking through the remote-access directive/clause list
for (r=rma; r; r=r->next)
{
remv = (rem_var *)(el->lhs())->attributeValue(0, REMOTE_VARIABLE);
if(!remv) continue; // error case: illegal reference in REMOTE_ACCESS directive/clause
ae = DVM000(remv->index + remv->ncolon + 1);
l = new SgExprListExp(*new SgArrayRefExp(*baseMemory(el->lhs()->symbol()->type()->baseType()), *ae));
l->setRhs(rem_list);
rem_list = l;
for (el = r->rml; el; el = el->rhs())
{
remv = (rem_var *)(el->lhs())->attributeValue(0, REMOTE_VARIABLE);
if(!remv) continue; // error case: illegal reference in REMOTE_ACCESS directive/clause
if (IS_REMOTE_ACCESS_BUFFER(remv->buffer) )
l = new SgExprListExp(*new SgArrayRefExp(*baseMemory(el->lhs()->symbol()->type()->baseType())));
else
{
ae = DVM000(remv->index + remv->ncolon + 1);
l = new SgExprListExp(*new SgArrayRefExp(*baseMemory(el->lhs()->symbol()->type()->baseType()), *ae));
}
l->setRhs(rem_list);
rem_list = l;
}
}
addr_list = AddListToList(rem_list, addr_list);
return(addr_list);
}
@@ -5523,12 +5574,12 @@ SgStatement *Create_Host_Across_Loop_Subroutine(SgSymbol *sHostProc)
SgStatement *Create_Host_Across_Loop_Subroutine(SgSymbol *sHostProc)
{
SgStatement *stmt = NULL, *st_end = NULL, *st_hedr = NULL, *cur = NULL, *last_decl = NULL;
SgExpression *ae = NULL, *arg_list = NULL, *el = NULL, *de = NULL, *tail = NULL, *baseMem_list = NULL;
SgExpression *ae = NULL, *arg_list = NULL, *el = NULL, *de = NULL, *tail = NULL, *baseMem_list = NULL;
SgSymbol *s_loop_ref = NULL, *sarg = NULL, *h_first = NULL, *h_last = NULL,*hl = NULL;
symb_list *sl = NULL;
SgType *tdvm = NULL;
SgType *tdvm = NULL;
int ln, nbuf = 0;
char *name = NULL;
char *name = NULL;
SgExprListExp *list = isSgExprListExp(dvm_parallel_dir->expr(2)); // do_variables list
SgSymbol *sHostAcrossProc;
@@ -5568,14 +5619,20 @@ SgStatement *Create_Host_Across_Loop_Subroutine(SgSymbol *sHostProc)
arg_list = arg_list->rhs();
if (!ln)
h_first = sarg;
}
}
h_last = sarg;
// add dvm-array-address list
if (options.isOn(O_HOST))
{
tail = arg_list;
for (sl = acc_array_list, hl = h_first; sl; sl = sl->next, hl = hl->next())
{
{
if (IS_REMOTE_ACCESS_BUFFER(sl->symb)) // case of RTS2 interface
{
sarg = DummyDvmBufferSymbol(sl->symb, hl);
nbuf++;
}
else
sarg = DummyDvmArraySymbol(sl->symb, hl);
ae = new SgArrayRefExp(*sarg);
arg_list->setRhs(*new SgExprListExp(*ae));
@@ -5666,6 +5723,33 @@ SgStatement *Create_Host_Across_Loop_Subroutine(SgSymbol *sHostProc)
st_end->insertStmtBefore(*stmt, *st_hedr);
//stmt = PrintStat(which_run_expr);
//st_end->insertStmtBefore(*stmt, *st_hedr);
// create argument list of handler's call
SgExpression *new_arg_list = &st_hedr->expr(0)->copy();
if (nbuf > 0) // there is REMOTE_ACCESS clause and RTS2 interface is used
// correct argument list of handler's call
{
el = new_arg_list->rhs();
while(el->lhs()->symbol() != h_last->next())
el = el->rhs();
for (sl = acc_array_list, hl = h_first; sl; sl = sl->next, hl = hl->next(), el = el->rhs())
{
if (IS_REMOTE_ACCESS_BUFFER(sl->symb))
{
// correct argument: buffer => buffer(buf_header(Rank+2))
SgArrayRefExp *buf_ref = new SgArrayRefExp(*hl,*new SgValueExp(Rank(sl->symb)+2));
el->lhs()->setLhs(*new SgExprListExp(*buf_ref));
// generate call statements of 'dvmh_loop_get_remote_buf' for remote access buffers
stmt = GetRemoteBuf(s_loop_ref, nbuf--, hl);
last_decl->insertStmtAfter(*stmt, *st_hedr);
}
}
// create external statement
stmt = new SgStatement(EXTERN_STAT);
el = new SgExprListExp(*new SgVarRefExp(fdvm[GET_REMOTE_BUF]));
stmt->setExpression(0, *el);
last_decl->insertStmtAfter(*stmt, *st_hedr);
}
SgIfStmt *ifstmt = NULL;
SgStatement *falsestmt = NULL;
@@ -5678,12 +5762,12 @@ SgStatement *Create_Host_Across_Loop_Subroutine(SgSymbol *sHostProc)
fbtest->addArg(*which_run_expr);
fbtest->addArg(*new SgValueExp(i - 1));
if (i != 0)
{
{
SgCallStmt *truestmt = new SgCallStmt(*sl->symb, *new_arg_list);
ifstmt = new SgIfStmt(*fbtest, *truestmt, *falsestmt);
falsestmt = ifstmt;
}
else {
else {
falsestmt = new SgCallStmt(*sl->symb, *new_arg_list);
}
i++;
@@ -5692,6 +5776,148 @@ SgStatement *Create_Host_Across_Loop_Subroutine(SgSymbol *sHostProc)
if (ifstmt) st_end->insertStmtBefore(*ifstmt, *st_hedr);
return(st_hedr);
}
SgStatement *Create_Host_Loop_Subroutine_Main (SgSymbol *sHostProc)
{
SgStatement *stmt = NULL, *st_end = NULL, *st_hedr = NULL, *last_decl = NULL;
SgExpression *ae, *arg_list = NULL, *el = NULL, *de = NULL, *tail = NULL, *baseMem_list = NULL;
SgSymbol *s_loop_ref = NULL, *sarg = NULL, *h_first = NULL, *h_last = NULL, *hl = NULL, *bl = NULL;
SgSymbol *s = NULL;
symb_list *sl = NULL;
int ln, nbuf = 0;
SgSymbol *sHostProc_RA;
if(rma && !rma->rmout && !rma->rml->symbol() && parloop_by_handler == 2 && WhatInterface(dvm_parallel_dir) == 2 )// there is synchronous REMOTE_ACCESS clause in PARALLEL directive and RTS2 interface is used
// create additional procedure for creating headers of remote access buffers
{
sHostProc_RA = HostProcSymbol_RA(sHostProc);
Create_Host_Loop_Subroutine (sHostProc_RA, 0);
}
else
return (Create_Host_Loop_Subroutine (sHostProc, 0));
// create Host procedure header and end for subroutine named by sHostProc
st_hedr = CreateHostProcedure(sHostProc);
st_hedr->addComment(Host_LoopHandlerComment());
st_end = st_hedr->lexNext();
// create dummy argument list
// loop_ref,<dvm_array_headers>,<dvm_array_bases>,<uses>
s_loop_ref = new SgSymbol(VARIABLE_NAME, "loop_ref", *FortranDvmType(), *st_hedr);
ae = new SgVarRefExp(s_loop_ref);
arg_list = new SgExprListExp(*ae);
st_hedr->setExpression(0, *arg_list);
// add dvm-array-header list
for (sl = acc_array_list, ln = 0; sl; sl = sl->next, ln++)
{
sarg = DummyDvmHeaderSymbol(sl->symb,st_hedr);
ae = new SgArrayRefExp(*sarg);
arg_list->setRhs(*new SgExprListExp(*ae));
arg_list = arg_list->rhs();
if (!ln)
h_first = sarg;
}
h_last = sarg;
// add dvm-array-address list
if (options.isOn(O_HOST))
{
tail = arg_list;
for (sl = acc_array_list, hl = h_first; sl; sl = sl->next, hl = hl->next())
{
if(IS_REMOTE_ACCESS_BUFFER(sl->symb))
{
sarg = DummyDvmBufferSymbol(sl->symb, hl);
nbuf++;
}
else
sarg = DummyDvmArraySymbol(sl->symb, hl);
ae = new SgArrayRefExp(*sarg);
arg_list->setRhs(*new SgExprListExp(*ae));
arg_list = arg_list->rhs();
}
tail = tail->rhs();
}
else
// create memory base list and add it to the dummy argument list
{
baseMem_list = tail = CreateBaseMemoryList();
AddListToList(arg_list, baseMem_list);
}
// add use's list to dummy argument list
if (uses_list)
{
AddListToList(arg_list, copy_uses_list = &(uses_list->copy()));
if (!tail)
tail = copy_uses_list;
}
if(red_list)
{
SgExpression * red_bound_list;
AddListToList(arg_list, red_bound_list = DummyListForReductionArrays(st_hedr));
if(!tail)
tail = red_bound_list;
}
// create external statement
stmt = new SgStatement(EXTERN_STAT);
el = new SgExprListExp(*new SgVarRefExp(fdvm[GET_REMOTE_BUF]));
el->setRhs(*new SgExprListExp(*new SgVarRefExp(sHostProc_RA)));
stmt->setExpression(0, *el);
st_hedr->insertStmtAfter(*stmt, *st_hedr);
last_decl = stmt;
// create dummy argument declarations
for (el = tail; el; el = el->rhs())
{
stmt = el->lhs()->symbol()->makeVarDeclStmt();
ConstantSubstitutionInTypeSpec(stmt->expr(1));
st_hedr->insertStmtAfter(*stmt, *st_hedr);
}
el = st_hedr->expr(0);
stmt = el->lhs()->symbol()->makeVarDeclStmt();
st_hedr->insertStmtAfter(*stmt, *st_hedr);
de = stmt->expr(0);
for (el = el->rhs(); el != tail; el = el->rhs())
{ //printf("%s \n",el->lhs()->symbol()->identifier());
de->setRhs(new SgExprListExp(*el->lhs()->symbol()->makeDeclExpr()));
de = de->rhs();
}
// generate IMPLICIT NONE statement
st_hedr->insertStmtAfter(*new SgStatement(IMPL_DECL), *st_hedr);
// generate handler call
stmt = new SgCallStmt(*sHostProc_RA, (st_hedr->expr(0))->copy());
last_decl->insertStmtAfter(*stmt, *st_hedr);
el = stmt->expr(0)->rhs();
// correct argument list of handler call
while(el->lhs()->symbol() != h_last->next())
el = el->rhs();
for (sl = acc_array_list, hl = h_first; sl; sl = sl->next, hl = hl->next(), el = el->rhs())
{
if (IS_REMOTE_ACCESS_BUFFER(sl->symb))
{
// correct argument: buffer => buffer(buf_header(Rank+2))
SgArrayRefExp *buf_ref = new SgArrayRefExp(*hl,*new SgValueExp(Rank(sl->symb)+2));
el->lhs()->setLhs(*new SgExprListExp(*buf_ref));
// generate call statements of 'dvmh_loop_get_remote_buf' for remote access buffers
stmt = GetRemoteBuf(s_loop_ref, nbuf--, hl);
last_decl->insertStmtAfter(*stmt, *st_hedr);
}
}
return (st_hedr);
}
SgStatement *Create_Host_Loop_Subroutine(SgSymbol *sHostProc, int dependency)
{
@@ -5714,7 +5940,6 @@ SgStatement *Create_Host_Loop_Subroutine(SgSymbol *sHostProc, int dependency)
tail = NULL;
addopenmp = 1; /* OpenMP */
// create Host procedure header and end
// create Host procedure header and end
st_hedr = CreateHostProcedure(sHostProc);
st_hedr->addComment(Host_LoopHandlerComment());
@@ -6866,6 +7091,13 @@ SgSymbol *DummyDvmArraySymbol(SgSymbol *ar, SgSymbol *header_symb)
typearray->addRange(*Dimension(header_symb, rank, rank));
return(new SgSymbol(VARIABLE_NAME, ar->identifier(), *typearray, *header_symb->scope()));
}
SgSymbol *DummyDvmBufferSymbol(SgSymbol *ar, SgSymbol *header_symb)
{
SgArrayType *typearray = new SgArrayType(*ar->type()->baseType());
typearray->addRange(*Dimension(header_symb, 1, 1));
return(new SgSymbol(VARIABLE_NAME, ar->identifier(), *typearray, *header_symb->scope()));
}
SgExpression *Dimension(SgSymbol *hs, int i, int rank)
{
@@ -12762,7 +12994,7 @@ SgStatement *Create_C_Adapter_Function(SgSymbol *sadapter, int InternalPosition)
SgStatement *Create_C_Adapter_Function(SgSymbol *sadapter)
{
symb_list *sl;
symb_list *sl;
SgStatement *st_hedr, *st_end, *stmt, *do_while, *first_exec, *st_base = NULL, *st_call, *cur;
SgExpression *fe, *ae, *arg_list, *el, *e, *er;
SgExpression *espec;
@@ -12773,11 +13005,11 @@ SgStatement *Create_C_Adapter_Function(SgSymbol *sadapter)
SgSymbol *s_dev_num = NULL, *s_shared_mem = NULL, *s_regs = NULL, *s_blocksS = NULL, *s_idxL = NULL, *s_idxH = NULL, *s_step = NULL, *s_idxTypeInKernel = NULL;
SgSymbol *s_num_of_red_blocks = NULL, *s_fill_flag = NULL, *s_red_num = NULL, *s_restBlocks = NULL, *s_addBlocks = NULL, *s_overallBlocks = NULL;
SgSymbol *s_max_blocks;
SgType *typ = NULL;
SgType *typ = NULL;
int ln, num, i, uses_num, shared_mem_count, has_red_array, use_device_num, nbuf;
char *define_name;
int pl_rank = ParLoopRank();
h_first = hgpu_first = base_first = red_first = uses_first = scalar_first = NULL;
h_first = hgpu_first = base_first = red_first = uses_first = scalar_first = NULL;
has_red_array = 0; use_device_num = 0; nbuf = 0;
s_dev_num = NULL;
s_shared_mem = NULL;
@@ -12814,6 +13046,8 @@ SgStatement *Create_C_Adapter_Function(SgSymbol *sadapter)
arg_list->setRhs(*new SgExprListExp(*ae));
arg_list = arg_list->rhs();
if (!ln)
h_first = sarg;
if (IS_REMOTE_ACCESS_BUFFER(sl->symb)) // case of RTS2 interface
nbuf++;
}
for (el = uses_list, ln = 0; el; el = el->rhs(), ln++) // uses
@@ -13101,12 +13335,18 @@ SgStatement *Create_C_Adapter_Function(SgSymbol *sadapter)
/* -------- call dvmh_get_natural_base(long *deviceRef, long dvmDesc[] ) ----*/
for (sl = acc_array_list, s = h_first, sb = base_first, ln = 0; ln < num; sl = sl->next, s = s->next(), sb = sb->next(), ln++)
{
s_dev_num = doDeviceNumVar(st_hedr, first_exec, s_dev_num, s_loop_ref);
e = &SgAssignOp(*new SgVarRefExp(sb), *GetNaturalBase(s_dev_num, s));
e = &SgAssignOp(*new SgVarRefExp(sb), *GetNaturalBase(s_dev_num, s));
stmt = cur = new SgCExpStmt(*e);
st_end->insertStmtBefore(*stmt, *st_hedr);
if (IS_REMOTE_ACCESS_BUFFER(sl->symb)) // case of RTS2 interface
{
e = LoopGetRemoteBuf(s_loop_ref, nbuf--, s);
stmt = new SgCExpStmt(*e);
cur->insertStmtBefore(*stmt, *st_hedr);
}
if (!ln)
{

26
dvm/fdvm/trunk/fdvm/acc_across.cpp
View File

@@ -1125,7 +1125,7 @@ vector<ArgsForKernel> Create_C_Adapter_Function_Across_OneThread(SgSymbol *sadap
SgType *typ;
SgFunctionCallExp *funcCall;
vector<char*> dvm_array_headers;
int ln, num, uses_num, has_red_array, use_device_num, num_of_red_arrays = 0;
int ln, num, uses_num, has_red_array, use_device_num, num_of_red_arrays = 0, nbuf = 0;
// init block
reduction_ptr = NULL;
@@ -1176,6 +1176,8 @@ vector<ArgsForKernel> Create_C_Adapter_Function_Across_OneThread(SgSymbol *sadap
arg_list = arg_list->rhs();
if (!ln)
h_first = sarg;
if (IS_REMOTE_ACCESS_BUFFER(sl->symb)) // case of RTS2 interface
nbuf++;
}
for (el = uses_list, ln = 0; el; el = el->rhs(), ++ln) // <uses>
@@ -1394,12 +1396,19 @@ vector<ArgsForKernel> Create_C_Adapter_Function_Across_OneThread(SgSymbol *sadap
/* -------- call dvmh_get_natural_base(long *deviceRef, long dvmDesc[] ) ----*/
for (s = h_first, sb = base_first, ln = 0; ln < num; s = s->next(), sb = sb->next(), ln++)
for (sl = acc_array_list, s = h_first, sb = base_first, ln = 0; ln < num; sl = sl->next, s = s->next(), sb = sb->next(), ln++)
{
s_dev_num = doDeviceNumVar(st_hedr, first_exec, s_dev_num, s_loop_ref);
e = &SgAssignOp(*new SgVarRefExp(sb), *GetNaturalBase(s_dev_num, s));
stmt = new SgCExpStmt(*e);
SgStatement *cur = stmt;
st_end->insertStmtBefore(*stmt, *st_hedr);
if (IS_REMOTE_ACCESS_BUFFER(sl->symb)) // case of RTS2 interface
{
e = LoopGetRemoteBuf(s_loop_ref, nbuf--, s);
stmt = new SgCExpStmt(*e);
cur->insertStmtBefore(*stmt, *st_hedr);
}
if (!ln)
stmt->addComment("// Get natural bases");
}
@@ -1754,7 +1763,7 @@ vector<ArgsForKernel> Create_C_Adapter_Function_Across_variants(SgSymbol *sadapt
SgType *typ;
SgFunctionCallExp *funcCall, *funcCallKernel;
vector<char*> dvm_array_headers;
int ln, num, uses_num, has_red_array, use_device_num, num_of_red_arrays;
int ln, num, uses_num, has_red_array, use_device_num, num_of_red_arrays, nbuf = 0;
// init block
lowI = highI = idxI = elem = red_blocks = shared_mem = stream_t = bIdxs = NULL;
@@ -1812,6 +1821,8 @@ vector<ArgsForKernel> Create_C_Adapter_Function_Across_variants(SgSymbol *sadapt
arg_list = arg_list->rhs();
if (!ln)
h_first = sarg;
if (IS_REMOTE_ACCESS_BUFFER(sl->symb)) // case of RTS2 interface
nbuf++;
}
for (el = uses_list, ln = 0; el; el = el->rhs(), ++ln) // <uses>
@@ -2297,12 +2308,19 @@ vector<ArgsForKernel> Create_C_Adapter_Function_Across_variants(SgSymbol *sadapt
/* -------- call dvmh_get_natural_base(long *deviceRef, long dvmDesc[] ) ----*/
for (s = h_first, sb = base_first, ln = 0; ln < num; s = s->next(), sb = sb->next(), ln++)
for (sl = acc_array_list, s = h_first, sb = base_first, ln = 0; ln < num; sl = sl->next, s = s->next(), sb = sb->next(), ln++)
{
s_dev_num = doDeviceNumVar(st_hedr, first_exec, s_dev_num, s_loop_ref);
e = &SgAssignOp(*new SgVarRefExp(sb), *GetNaturalBase(s_dev_num, s));
stmt = new SgCExpStmt(*e);
SgStatement *cur = stmt;
st_end->insertStmtBefore(*stmt, *st_hedr);
if (IS_REMOTE_ACCESS_BUFFER(sl->symb)) // case of RTS2 interface
{
e = LoopGetRemoteBuf(s_loop_ref, nbuf--, s);
stmt = new SgCExpStmt(*e);
cur->insertStmtBefore(*stmt, *st_hedr);
}
if (!ln)
stmt->addComment("// Get natural bases");
}

50
dvm/fdvm/trunk/fdvm/dvm.cpp
View File

@@ -9683,6 +9683,21 @@ void RemoteAccessDirective(SgStatement *stmt)
RemoteVariableList(stmt->symbol(),stmt->expr(0),stmt);
}
SgExpression *AlignmentListForRemoteDir(int nt, SgExpression *axis[], SgExpression *coef[], SgExpression *cons[])
{ // case of RTS2 interface
SgExpression *arglist=NULL, *el, *e;
for(int i=0; i<nt; i++)
{
e = AlignmentLinear(axis[i],ReplaceFuncCall(coef[i]),cons[i]);
(el = new SgExprListExp(*e))->setRhs(arglist);
arglist = el;
}
(el = new SgExprListExp(*ConstRef(nt)))->setRhs(arglist); // add rank to axis list
arglist = el;
return arglist;
}
void RemoteVariableList1(SgSymbol *group,SgExpression *rml, SgStatement *stmt)
{ SgStatement *if_st,*end_st = NULL;
SgExpression *el, *es;
@@ -9751,7 +9766,10 @@ void RemoteVariableList(SgSymbol *group, SgExpression *rml, SgStatement *stmt)
return;
if(IN_COMPUTE_REGION && group)
err("Asynchronous REMOTE_ACCESS clause in compute region",574,stmt);
if(group && parloop_by_handler == 2 && stmt->variant() != DVM_PARALLEL_ON_DIR ) { // case of REMOTE_ACCESS directive
err("Illegal directive in -Opl2 mode. Asynchronous operations are not supported in this mode", 649, stmt);
group = NULL;
}
if(group){
if_st = doIfThenConstrForRemAcc(group,cur_st);
end_st = cur_st; //END IF
@@ -9824,7 +9842,7 @@ void RemoteVariableList(SgSymbol *group, SgExpression *rml, SgStatement *stmt)
} else {
axis[n] = &c0.copy();
coef[n] = &c0.copy();
cons[n] = &(es->lhs()->copy() - *Exprn( LowerBound(el->lhs()->symbol(),n))) ;
cons[n] = parloop_by_handler == 2 ? &es->lhs()->copy() : &(es->lhs()->copy() - *Exprn( LowerBound(el->lhs()->symbol(),n))) ;
ind_deb[n] = &(cons[n]->copy());
//init[n] = &c0.copy();
//last[n] = &c0.copy();
@@ -9869,6 +9887,22 @@ void RemoteVariableList(SgSymbol *group, SgExpression *rml, SgStatement *stmt)
//buffer_head = DVM000(ibuf);
ar = NULL;
}
// adding attribute REMOTE_VARIABLE
rem_var *remv = new rem_var;
remv->ncolon = nc;
remv->index = ibuf;
remv->amv = group ? 1 : iamv;
remv->buffer = NULL; /*ACC*/
(el->lhs())->addAttribute(REMOTE_VARIABLE,(void *) remv, sizeof(rem_var));
// case of RTS2-interface
if(parloop_by_handler==2) {
if(stmt->variant() != DVM_PARALLEL_ON_DIR) {
doCallAfter(RemoteAccess_H2(header_rf(ar,ibuf,1), el->lhs()->symbol(), HeaderRef(el->lhs()->symbol()), AlignmentListForRemoteDir(n,axis,coef,cons)));
}
continue;
}
// creating buffer for remote elements of array
iaxis = ndvm;
if (stmt->variant() == DVM_PARALLEL_ON_DIR) {
@@ -9920,17 +9954,9 @@ void RemoteVariableList(SgSymbol *group, SgExpression *rml, SgStatement *stmt)
}
InsertNewStatementAfter(D_RmBuf( HeaderRef(el->lhs()->symbol()),GetAddresDVM( header_rf(ar,ibuf,1)),n,ideb),cur_st,cur_st->controlParent());
}
SET_DVM(iaxis);
//adding attribute REMOTE_VARIABLE
rem_var *remv = new rem_var;
remv->ncolon = nc;
remv->index = ibuf;
remv->amv = group ? 1 : iamv;
remv->buffer = NULL; /*ACC*/
(el->lhs())->addAttribute(REMOTE_VARIABLE,(void *) remv, sizeof(rem_var));
SET_DVM(iaxis);
}
if(group) {
cur_st = cur_st->lexNext()->lexNext();//IF THEN after ELSE
doAssignStmtAfter(WaitBG(GROUP_REF(group,1)));

49
dvm/fdvm/trunk/fdvm/funcall.cpp
View File

@@ -3702,13 +3702,16 @@ SgStatement *Consistent_H (int il, SgExpression *hedr, SgExpression *axis_list)
return(call);
}
SgStatement *LoopRemoteAccess_H (int il, SgExpression *hedr, SgExpression *axis_list)
{// generating subroutine call: dvmh_loop_remote_access_(const DvmType *pCurLoop, const DvmType dvmDesc[], const DvmType *pRank, /* const DvmType *pAlignmentHelper */...)
SgStatement *LoopRemoteAccess_H (int il, SgExpression *hedr, SgSymbol *ar, SgExpression *axis_list)
{// generating subroutine call: dvmh_loop_remote_access_(const DvmType *pCurLoop, const DvmType dvmDesc[], const void *baseAddr, const DvmType *pRank, /* const DvmType *pAlignmentHelper */...)
// DvmhLoopRef - result of dvmh_loop_create()
SgCallStmt *call = new SgCallStmt(*fdvm[LOOP_REMOTE]);
fmask[LOOP_REMOTE] = 2;
call->addArg(*DVM000(il));
call->addArg(*hedr);
SgType *t = (isSgArrayType(ar->type())) ? ar->type()->baseType() : ar->type();
SgExpression *base = (t->variant() != T_DERIVED_TYPE && t->variant() != T_STRING ) ? new SgArrayRefExp(*baseMemory(SgTypeInt())) : new SgArrayRefExp(*baseMemory(t));
call->addArg(*base);
AddListToList(call->expr(0), axis_list);
return(call);
}
@@ -4411,6 +4414,16 @@ SgStatement *FillLocalPart_HH(SgSymbol *loop_s, SgSymbol *shead, SgSymbol *spart
return(call);
}
SgStatement *GetRemoteBuf (SgSymbol *loop_s, int n, SgSymbol *s_buf_head)
{// generating subroutine call: dvmh_loop_get_remote_buf_(const DvmType *pCurLoop, const DvmType *pRmaIndex, DvmType rmaDesc[]);
SgCallStmt *call = new SgCallStmt(*fdvm[GET_REMOTE_BUF]);
fmask[GET_REMOTE_BUF] = 2;
call->addArg(*new SgVarRefExp(loop_s));
call->addArg(*ConstRef_F95(n));
call->addArg(*new SgArrayRefExp(*s_buf_head));
return(call);
}
//------ Calls from handlers for sequence of statements --------------------
@@ -4707,13 +4720,14 @@ SgExpression *GetDeviceNum(SgSymbol *s_loop_ref)
{ // generating function call:
// DvmType loop_get_device_num_ (DvmhLoopRef *InDvmhLoop)
// or when RTS2 is used
// DvmType dvmh_loop_get_device_num_(const DvmType *pCurLoop)
// DvmType dvmh_loop_get_device_num_C ( DvmType curLoop)
int fNum = INTERFACE_RTS2 ? GET_DEVICE_NUM_2 : GET_DEVICE_NUM ;
int fNum = INTERFACE_RTS2 ? GET_DEVICE_NUM_2 : GET_DEVICE_NUM ;
SgFunctionCallExp *fe = new SgFunctionCallExp(*fdvm[fNum]);
fe->addArg(* new SgVarRefExp(s_loop_ref));
if(INTERFACE_RTS2)
fe->addArg(SgDerefOp(*new SgVarRefExp(s_loop_ref)));
else
fe->addArg(* new SgVarRefExp(s_loop_ref));
return(fe);
}
@@ -4751,6 +4765,15 @@ SgExpression *FillBounds(SgSymbol *loop_s, SgSymbol *sBlow,SgSymbol *sBhigh,SgSy
return(fe);
}
SgExpression *LoopGetRemoteBuf(SgSymbol *loop_s, int n, SgSymbol *s_buf_head)
{// generating function call: dvmh_loop_get_remote_buf_(const DvmType *pCurLoop, const DvmType *pRmaIndex, DvmType rmaDesc[]);
SgFunctionCallExp *fe = new SgFunctionCallExp(*fdvm[GET_REMOTE_BUF_C]);
fe->addArg(SgDerefOp(*new SgVarRefExp(loop_s)));
fe->addArg(*new SgValueExp(n));
fe->addArg(*new SgArrayRefExp(*s_buf_head));
return(fe);
}
SgExpression *RedPost(SgSymbol *loop_s, SgSymbol *s_var_num, SgSymbol *sRed,SgSymbol *sLoc)
{// generating function call:
// void loop_red_post_(DvmhLoopRef *InDvmhLoop, DvmType *InRedNum, void *arrayPtr, void *locPtr)
@@ -4761,7 +4784,7 @@ SgExpression *RedPost(SgSymbol *loop_s, SgSymbol *s_var_num, SgSymbol *sRed,SgSy
int fNum = INTERFACE_RTS2 ? RED_POST_2 : RED_POST_C ;
SgFunctionCallExp *fe = new SgFunctionCallExp(*fdvm[fNum]);
fe -> addArg(* new SgVarRefExp(loop_s));
fe->addArg(* new SgVarRefExp(loop_s));
fe->addArg(SgAddrOp(* new SgVarRefExp(s_var_num)));
fe->addArg(SgAddrOp(* new SgVarRefExp(sRed)));
if(sLoc)
@@ -4893,12 +4916,14 @@ SgExpression *GuessIndexType(SgSymbol *s_loop_ref)
{// generating function call:
// loop_guess_index_type_(DvmhLoopRef *InDvmhLoop)
// or when RTS2 is used
// dvmh_loop_guess_index_type_(const DvmType *pCurLoop)
// dvmh_loop_guess_index_type_C(DvmType *curLoop)
int fNum = INTERFACE_RTS2 ? GUESS_INDEX_TYPE_2 : GUESS_INDEX_TYPE ;
SgFunctionCallExp *fe = new SgFunctionCallExp(*fdvm[fNum]);
fe -> addArg(* new SgVarRefExp(s_loop_ref));
SgFunctionCallExp *fe = new SgFunctionCallExp(*fdvm[fNum]);
if(INTERFACE_RTS2)
fe->addArg(SgDerefOp(*new SgVarRefExp(s_loop_ref)));
else
fe->addArg(*new SgVarRefExp(s_loop_ref));
return(fe);
}

31
dvm/fdvm/trunk/fdvm/parloop.cpp
View File

@@ -460,7 +460,11 @@ int WhatInterface(SgStatement *stmt)
case ACC_TIE_OP:
case CONSISTENT_OP:
case STAGE_OP:
break;
case REMOTE_ACCESS_OP:
if(e->symbol()) // asynchronous REMOTE_ACCESS
return(1);
else
break;
case REDUCTION_OP:
if(TestReductionClause(e))
break;
@@ -2213,6 +2217,21 @@ SgExpression *AxisList(SgStatement *stmt, SgExpression *tied_array_ref)
return arglist;
}
SgExpression *ArrayRefAddition(SgExpression *aref)
{
if(!aref->lhs()) // without subscript list
{
// A => A(:,:,...,:)
SgExpression *arlist = NULL;
int n = Rank(aref->symbol());
while(n--)
arlist = AddListToList(arlist, new SgExprListExp(*new SgExpression(DDOT)));
aref->setLhs(arlist);
}
return aref;
}
SgExpression *MappingList(SgStatement *stmt, SgExpression *aref)
{
SgExpression *axis[MAX_LOOP_LEVEL],
@@ -2280,6 +2299,16 @@ void Interface_2(SgStatement *stmt,SgExpression *clause[],SgExpression *init[],S
for (SgExpression *el = clause[CONSISTENT_]->lhs(); el; el=el->rhs())
InsertNewStatementAfter(Consistent_H(ilh, HeaderForArrayInParallelDir(el->lhs()->symbol(), stmt, 0), MappingList(stmt, el->lhs())), cur_st, cur_st->controlParent());
if (clause[REMOTE_ACCESS_]) //there is REMOTE_ACCESS clause
{ int nbuf=1;
//adding new element to remote_access directive/clause list
AddRemoteAccess(clause[REMOTE_ACCESS_]->lhs(),NULL);
RemoteVariableList(clause[REMOTE_ACCESS_]->symbol(), clause[REMOTE_ACCESS_]->lhs(), stmt);
for (SgExpression *el=clause[REMOTE_ACCESS_]->lhs(); el; el=el->rhs(),nbuf++)
InsertNewStatementAfter(LoopRemoteAccess_H(ilh, HeaderForArrayInParallelDir(el->lhs()->symbol(), stmt, 0), el->lhs()->symbol(), MappingList(stmt, ArrayRefAddition(el->lhs()))), cur_st, cur_st->controlParent());
}
if (clause[SHADOW_COMPUTE_]) //there is SHADOW_COMPUTE clause
{
if ( (clause[SHADOW_COMPUTE_]->lhs()))

13
dvm/fdvm/trunk/include/dvm.h
View File

@@ -260,6 +260,7 @@ const int DEFERRED_SHAPE = 1049;
const int DEFERRED_SHAPE = 1049;
const int END_OF_USE_LIST = 1050; /*ACC*/
const int ROUTINE_ATTR = 1051; /*ACC*/
const int DATA_REGION_SYMB = 1052; /*ACC*/
const int REMOTE_ACCESS_BUF = 1053; /*ACC*/
const int MAX_LOOP_LEVEL = 20; // 7 - maximal number of loops in parallel loop nest
@@ -421,6 +422,7 @@ const int Logical_8 = 12;
#define HEADER_FOR_HANDLER(A) ( (SgSymbol **)(A)->attributeValue(0,HANDLER_HEADER) )
#define USE_STATEMENTS_ARE_REQUIRED ( (int *) first_do_par->attributeValue(0,MODULE_USE) )
#define DEFERRED_SHAPE_TEMPLATE(A) ( (ORIGINAL_SYMBOL(A))->attributeValue(0,DEFERRED_SHAPE) )
#define HAS_ROUTINE_ATTR(A) ((A)->attributeValue(0,ROUTINE_ATTR))
#define IS_REMOTE_ACCESS_BUFFER(A) ((A)->attributeValue(0,REMOTE_ACCESS_BUF))
EXTERN
@@ -674,6 +676,7 @@ int CreateBufferArray(int rank, SgExpression *rme, int *amview, SgStatement *stm
int CreateBufferArray(int rank, SgExpression *rme, int *amview, SgStatement *stmt);
void CopyToBuffer(int rank, int ibuf, SgExpression *rme);
void RemoteVariableList(SgSymbol *group,SgExpression *rml, SgStatement *stmt);
void RemoteVariableList1(SgSymbol *group,SgExpression *rml, SgStatement *stmt);
SgExpression *AlignmentListForRemoteDir(int nt, SgExpression *axis[], SgExpression *coef[], SgExpression *cons[]);
void DeleteBuffers(SgExpression *rml);
void AddRemoteAccess(SgExpression *rml, SgStatement *rmout);
@@ -1123,6 +1126,7 @@ void CudaBlockSize(SgExpression *cuda_block_list);
void CudaBlockSize(SgExpression *cuda_block_list);
void CudaBlockSize(SgExpression *cuda_block_list,SgExpression *esize[]);
int ListElemNumber(SgExpression *list);
SgStatement *Create_Host_Across_Loop_Subroutine(SgSymbol *sHostProc);
SgStatement *Create_Host_Loop_Subroutine_Main(SgSymbol *sHostProc);
SgStatement *Create_Host_Loop_Subroutine(SgSymbol *sHostProc, int type);
char * BoundName(SgSymbol *s, int i, int isLower);
@@ -1207,7 +1211,8 @@ void RefIn_LoopHeaderExpr(SgExpression *e,SgStatement *dost);
void RefIn_LoopHeaderExpr(SgExpression *e,SgStatement *dost);
SgSymbol *RemoteAccessBufferInKernel(SgSymbol *ar,int rank);
SgSymbol *isSameNameBuffer(char *name,SgExpression *rml);
SgExpression *RemoteAccessHeaderList();
SgExpression *RemoteAccessHeaderList();
void CreateRemoteAccessBuffersUp();
void CreateRemoteAccessBuffers(SgExpression *rml, int pl_flag);
coeffs *BufferCoeffs(SgSymbol *sbuf,SgSymbol *ar);
void AddRemoteAccessBufferList_ToArrayList();
@@ -1378,6 +1383,7 @@ char *Header_DummyArgName(SgSymbol *s);
char *Header_DummyArgName(SgSymbol *s);
SgExpression *Dimension(SgSymbol *hs, int i, int rank);
SgSymbol *DummyDvmHeaderSymbol(SgSymbol *ar, SgStatement *st_hedr);
SgSymbol *DummyDvmArraySymbol(SgSymbol *ar,SgSymbol *header_symb);
SgSymbol *DummyDvmBufferSymbol(SgSymbol *ar, SgSymbol *header_symb);
SgExpression *ElementOfAddrArgumentList(SgSymbol *s);
SgExpression *AddrArgumentList();
@@ -1821,6 +1827,7 @@ SgStatement *Realign_H(SgExpression *objref, int new_sign);
SgStatement *Realign_H(SgExpression *objref, int new_sign);
SgExpression *GetOverallStep(SgSymbol *s_loop_ref);
SgExpression *GetDeviceNum(SgSymbol *s_loop_ref);
SgExpression *FillBounds(SgSymbol *loop_s, SgSymbol *sBlow,SgSymbol *sBhigh,SgSymbol *sBstep);
SgExpression *LoopGetRemoteBuf(SgSymbol *loop_s, int n, SgSymbol *s_buf_head);
SgExpression *mallocFunction(SgExpression *arg, SgStatement *scope);
SgExpression *freeFunction(SgExpression *arg, SgStatement *scope);
@@ -1888,8 +1895,10 @@ SgStatement *DvmhArrayCopyWhole( SgExpression *array_header_right, SgExpression
SgStatement *DvmhArrayCopyWhole( SgExpression *array_header_right, SgExpression *array_header_left );
SgStatement *Correspondence_H (int il, SgExpression *hedr, SgExpression *axis_list);
SgStatement *DvmhArraySetValue( SgExpression *array_header_left, SgExpression *e_right );
SgStatement *Consistent_H (int il, SgExpression *hedr, SgExpression *axis_list);
SgStatement *Consistent_H (int il, SgExpression *hedr, SgExpression *axis_list);
SgStatement *LoopRemoteAccess_H (int il, SgExpression *hedr, SgSymbol *ar, SgExpression *axis_list);
SgStatement *RemoteAccess_H2 (SgExpression *buf_hedr, SgSymbol *ar, SgExpression *ar_hedr, SgExpression *axis_list);
SgStatement *GetRemoteBuf (SgSymbol *loop_s, int n, SgSymbol *s_buf_head);
/* io.cpp */
void IO_ThroughBuffer(SgSymbol *ar, SgStatement *stmt, SgExpression *eiostat);

6
dvm/fdvm/trunk/include/libdvm.h
View File

@@ -264,6 +264,7 @@ name_dvm[SET_VALUE] = "dvmh_array_set_value";
name_dvm[LOOP_CONSISTENT] = "dvmh_loop_consistent";
name_dvm[DVMH_REMOTE2] = "dvmh_remote_access2";
name_dvm[LOOP_REMOTE] = "dvmh_loop_remote_access";
name_dvm[GET_REMOTE_BUF] = "dvmh_loop_get_remote_buf";
name_dvm[FTN_OPEN] = "dvmh_ftn_open"; /* IO */
name_dvm[FTN_CLOSE] = "dvmh_ftn_close"; /* IO */
name_dvm[FTN_READ] = "dvmh_ftn_read_unf"; /* IO */
@@ -312,7 +313,7 @@ name_dvm[GET_DEVICE_ADDR_C]= "dvmh_get_device_addr_C";
name_dvm[GET_LOCAL_PART] = "loop_cuda_get_local_part";
name_dvm[GET_LOCAL_PART_C] = "dvmh_loop_cuda_get_local_part_C";
name_dvm[GET_DEVICE_NUM] = "loop_get_device_num_";
name_dvm[GET_DEVICE_NUM_2] = "dvmh_loop_get_device_num_";
name_dvm[GET_DEVICE_NUM_2] = "dvmh_loop_get_device_num_C";
name_dvm[GET_OVERALL_STEP] = "loop_cuda_get_red_step";
name_dvm[FILL_BOUNDS_C] = "loop_fill_bounds_";
name_dvm[FILL_BOUNDS_2] = "dvmh_loop_fill_bounds_";
@@ -330,5 +331,6 @@ name_dvm[GET_CONFIG] = "loop_cuda_get_config";
name_dvm[GET_CONFIG_C] = "dvmh_loop_cuda_get_config_C";
name_dvm[CHANGE_BOUNDS] = "dvmh_change_filled_bounds";
name_dvm[GUESS_INDEX_TYPE] = "loop_guess_index_type_";
name_dvm[GUESS_INDEX_TYPE_2]= "dvmh_loop_guess_index_type_";
name_dvm[GUESS_INDEX_TYPE_2]="dvmh_loop_guess_index_type_C";
name_dvm[RTC_SET_LANG] = "loop_cuda_rtc_set_lang";
name_dvm[GET_REMOTE_BUF_C] = "dvmh_loop_get_remote_buf_C";

2
dvm/fdvm/trunk/include/libnum.h
View File

@@ -265,6 +265,7 @@ enum {
LOOP_CONSISTENT,
DVMH_REMOTE2,
LOOP_REMOTE,
GET_REMOTE_BUF,
FTN_OPEN,
FTN_CLOSE,
FTN_READ,
@@ -330,5 +331,6 @@ enum {
GUESS_INDEX_TYPE,
GUESS_INDEX_TYPE_2,
RTC_SET_LANG,
GET_REMOTE_BUF_C,
MAX_LIBFUN_NUM
};