void releaseToIonMemory(char *fileName, int lineNbr, void *block) { PsmPartition ionwm = _ionwm(NULL); Psm_free(fileName, lineNbr, ionwm, psa(ionwm, (char *) block)); #ifdef HAVE_VALGRIND_VALGRIND_H VALGRIND_FREELIKE_BLOCK(block, 0); #endif }
IonNeighbor *addNeighbor(IonVdb *ionvdb, uvast nodeNbr) { PsmPartition ionwm = getIonwm(); IonNode *node; PsmAddress nextElt; PsmAddress addr; PsmAddress elt; IonNeighbor *neighbor; node = findNode(ionvdb, nodeNbr, &nextElt); if (node == NULL) { node = addNode(ionvdb, nodeNbr); if (node == NULL) { putErrmsg("Can't add neighboring node.", NULL); return NULL; } } addr = psm_zalloc(ionwm, sizeof(IonNeighbor)); if (addr == 0) { putErrmsg("Can't add neighbor.", NULL); return NULL; } neighbor = (IonNeighbor *) psp(ionwm, addr); CHKNULL(neighbor); memset((char *) neighbor, 0, sizeof(IonNeighbor)); neighbor->nodeNbr = nodeNbr; neighbor->node = psa(ionwm, node); elt = sm_rbt_insert(ionwm, ionvdb->neighbors, addr, rfx_order_neighbors, neighbor); if (elt == 0) { psm_free(ionwm, addr); putErrmsg("Can't add neighbor.", NULL); return NULL; } return neighbor; }
unsigned long ionMemPtoA(void *pointer) { return (unsigned long) psa(_ionwm(NULL), pointer); }
void releaseToIonMemory(char *fileName, int lineNbr, void *block) { PsmPartition ionwm = _ionwm(NULL); Psm_free(fileName, lineNbr, ionwm, psa(ionwm, (char *) block)); }
int main (int __argc, char *__argv[]) { peo :: init( __argc, __argv ); if (getNodeRank()==1) std::cout<<"\n\nTest : PSO Global Best\n\n"; rng.reseed (10); RingTopology topologyMig; eoGenContinue < Indi > genContPara (10); eoCombinedContinue <Indi> continuatorPara (genContPara); eoCheckPoint<Indi> checkpoint(continuatorPara); peoEvalFunc<Indi, double, const Indi& > plainEval(f); peoPopEval< Indi > eval(plainEval); eoUniformGenerator < double >uGen (0, 1.); eoInitFixedLength < Indi > random (2, uGen); eoUniformGenerator < double >sGen (-1., 1.); eoVelocityInitFixedLength < Indi > veloRandom (2, sGen); eoFirstIsBestInit < Indi > localInit; eoRealVectorBounds bndsFlight(2,0,1.); eoStandardFlight < Indi > flight(bndsFlight); eoPop < Indi > pop; pop.append (10, random); eoLinearTopology<Indi> topology(2); eoRealVectorBounds bnds(2,-1.,1.); eoStandardVelocity < Indi > velocity (topology,1,0.5,2.,bnds); eoInitializer <Indi> init(eval,veloRandom,localInit,topology,pop); eoPeriodicContinue< Indi > mig_cont( 2 ); peoPSOSelect<Indi> mig_selec(topology); peoGlobalBestVelocity<Indi> mig_replac (2.,velocity); eoContinuator<Indi> cont(mig_cont, pop); eoSelector <Indi, eoPop<Indi> > mig_select (mig_selec,1,pop); eoReplace <Indi, eoPop<Indi> > mig_replace (mig_replac,pop); eoGenContinue < Indi > genContPara2 (10); eoCombinedContinue <Indi> continuatorPara2 (genContPara2); eoCheckPoint<Indi> checkpoint2(continuatorPara2); peoEvalFunc<Indi, double, const Indi& > plainEval2(f); peoPopEval< Indi > eval2(plainEval2); eoUniformGenerator < double >uGen2 (0, 1.); eoInitFixedLength < Indi > random2 (2, uGen2); eoUniformGenerator < double >sGen2 (-1., 1.); eoVelocityInitFixedLength < Indi > veloRandom2 (2, sGen2); eoFirstIsBestInit < Indi > localInit2; eoRealVectorBounds bndsFlight2(2,0,1.); eoStandardFlight < Indi > flight2(bndsFlight2); eoPop < Indi > pop2; pop2.append (10, random2); eoLinearTopology<Indi> topology2(2); eoRealVectorBounds bnds2(2,-1.,1.); eoStandardVelocity < Indi > velocity2 (topology2,1,0.5,2.,bnds2); eoInitializer <Indi> init2(eval2,veloRandom2,localInit2,topology2,pop2); eoPeriodicContinue< Indi > mig_cont2( 2 ); peoPSOSelect<Indi> mig_selec2(topology2); peoGlobalBestVelocity<Indi> mig_replac2 (2.,velocity2); eoContinuator<Indi> cont2(mig_cont2,pop2); eoSelector <Indi, eoPop<Indi> > mig_select2 (mig_selec2,1,pop2); eoReplace <Indi, eoPop<Indi> > mig_replace2 (mig_replac2,pop2); peoAsyncIslandMig< eoPop<Indi>, eoPop<Indi> > mig(cont,mig_select, mig_replace, topologyMig); checkpoint.add( mig ); peoAsyncIslandMig< eoPop<Indi>, eoPop<Indi> > mig2(cont2,mig_select2, mig_replace2, topologyMig); checkpoint2.add( mig2 ); eoSyncEasyPSO <Indi> psa(init,checkpoint,eval, velocity, flight); peoWrapper parallelPSO( psa, pop); eval.setOwner(parallelPSO); mig.setOwner(parallelPSO); eoSyncEasyPSO <Indi> psa2(init2,checkpoint2,eval2, velocity2, flight2); peoWrapper parallelPSO2( psa2, pop2); eval2.setOwner(parallelPSO2); mig2.setOwner(parallelPSO2); peo :: run(); peo :: finalize(); if (getNodeRank()==1) { pop.sort(); pop2.sort(); std::cout << "Final population :\n" << pop << std::endl; std::cout << "Final population :\n" << pop2 << std::endl; } }
static unsigned long dgrPtoA(void *pointer) { return (unsigned long) psa(dgrwm, pointer); }
static void releaseToDgrMemory(const char *fileName, int lineNbr, void *block) { Psm_free(fileName, lineNbr, dgrwm, psa(dgrwm, (char *) block)); }
static int F() { // function declaration Tdata_type ftype; switch (token.type) { case TT_INT: case TT_DOUBLE: case TT_STRING: // rule: type idf ( AL ) FD ftype = get_type(); tmp_ftype = ftype; next(); check(TT_ID); try(add_func(ftype, token.p_string)); next(); term(TT_L_BRACKET); call(AL); term(TT_R_BRACKET); return(FD); default: return ERR_PARSER; } } static int AL() { // first function argument switch (token.type) { case TT_INT: case TT_DOUBLE: case TT_STRING: // rule: AL -> AD AL2 call(AD); return(AL2); default: // rule: AL -> eps return OK; } } static int AL2() { // remaining function arguments switch (token.type) { case TT_COMMA: // rule: AL2 -> , AD AL2 next(); call(AD); return(AL2); default: // rule: AL2 -> eps return OK; } } static int AD() { // argument Tdata_type atype; switch (token.type) { case TT_INT: case TT_DOUBLE: case TT_STRING: // rule: AD -> type id atype = get_type(); next(); check(TT_ID); try(add_param(atype, token.p_string)); next(); return OK; default: return ERR_PARSER; } } static int FD() { // function definition unsigned i; switch (token.type) { case TT_SEMICOLON: // rule: FD -> ; try(func_declaration()); next(); return OK; case TT_OPEN_BRACKET: // rule: FD -> { STL } i = get_line(); try(func_definition(i)); // instruction pointer next(); call(STL); term(TT_CLOSE_BRACKET); remove_block(); generate(I_ERR, NULL, NULL, NULL); // no return => runtime error return OK; default: return ERR_PARSER; } } static int STL() { // stat list switch (token.type) { case TT_CLOSE_BRACKET: // rule: STL -> eps return OK; default: // rule: STL -> S STL call(S); return(STL); } } static int S() { // stat unsigned i; Tlocal_sym_tab_node *conv; switch (token.type) { case TT_AUTO: case TT_INT: case TT_DOUBLE: case TT_STRING: // rule: S -> D ; call(D); term(TT_SEMICOLON); return OK; case TT_OPEN_BRACKET: // rule: S -> { STL } next(); try(add_block()); call(STL); term(TT_CLOSE_BRACKET); remove_block(); return OK; case TT_IF: // rule: S -> if ( E ) S else S next(); term(TT_L_BRACKET); call(E); try(type_compare(tmp_psitem.type, TYPE_INT)); if (tmp_psitem.type != TYPE_INT) { try(tmp_var(TYPE_INT, &conv)); generate(I_CONVERT, tmp_psitem.value.ptr, NULL, conv); } else { conv = tmp_psitem.value.ptr; } Tlocal_sym_tab_node *label; try(tmp_var(TYPE_INT, &label)); generate(I_JUMPIFN, conv, label, NULL); term(TT_R_BRACKET); call(S); Tlocal_sym_tab_node *endif; try(tmp_var(TYPE_INT, &endif)); generate(I_JUMP, NULL, endif, NULL); i = get_line(); set_var_value_int(label->name, i); call(ELSE); i = get_line(); set_var_value_int(endif->name, i); return OK; case TT_FOR: // rule: S -> for ( D ; E ; E ) S try(add_block()); next(); term(TT_L_BRACKET); call(D); term(TT_SEMICOLON); Tlocal_sym_tab_node *cond; try(tmp_var(TYPE_INT, &cond)); i = get_line(); set_var_value_int(cond->name, i); call(E); try(type_compare(tmp_psitem.type, TYPE_INT)); if (tmp_psitem.type != TYPE_INT) { try(tmp_var(TYPE_INT, &conv)); generate(I_CONVERT, tmp_psitem.value.ptr, NULL, conv); } else { conv = tmp_psitem.value.ptr; } Tlocal_sym_tab_node *endfor; try(tmp_var(TYPE_INT, &endfor)); generate(I_JUMPIFN, conv, endfor, NULL); Tlocal_sym_tab_node *statlist; try(tmp_var(TYPE_INT, &statlist)); generate(I_JUMP, NULL, statlist, NULL); Tlocal_sym_tab_node *assign; try(tmp_var(TYPE_INT, &assign)); i = get_line(); set_var_value_int(assign->name, i); term(TT_SEMICOLON); call(E); generate(I_JUMP, NULL, cond, NULL); i = get_line(); set_var_value_int(statlist->name, i); term(TT_R_BRACKET); call(S); generate(I_JUMP, NULL, assign, NULL); i = get_line(); set_var_value_int(endfor->name, i); remove_block(); return OK; case TT_WHILE: // rule: S -> while ( E ) S next(); term(TT_L_BRACKET); Tlocal_sym_tab_node *wcond; try(tmp_var(TYPE_INT, &wcond)); i = get_line(); set_var_value_int(wcond->name, i); call(E); try(type_compare(tmp_psitem.type, TYPE_INT)); if (tmp_psitem.type != TYPE_INT) { try(tmp_var(TYPE_INT, &conv)); generate(I_CONVERT, tmp_psitem.value.ptr, NULL, conv); } else { conv = tmp_psitem.value.ptr; } Tlocal_sym_tab_node *endwhile; try(tmp_var(TYPE_INT, &endwhile)); generate(I_JUMPIFN, conv, endwhile, NULL); term (TT_R_BRACKET); call(S); generate(I_JUMP, NULL, wcond, NULL); i = get_line(); set_var_value_int(endwhile->name, i); return OK; case TT_DO: // rule: S -> do S while ( E ) ; next(); Tlocal_sym_tab_node *dwbody; try(tmp_var(TYPE_INT, &dwbody)); i = get_line(); set_var_value_int(dwbody->name, i); call(S); term(TT_WHILE); term(TT_L_BRACKET); call(E); try(type_compare(tmp_psitem.type, TYPE_INT)); if (tmp_psitem.type != TYPE_INT) { try(tmp_var(TYPE_INT, &conv)); generate(I_CONVERT, tmp_psitem.value.ptr, NULL, conv); } else { conv = tmp_psitem.value.ptr; } generate(I_JUMPIF, conv, dwbody, NULL); term(TT_R_BRACKET); term(TT_SEMICOLON); return OK; case TT_RETURN: // rule: S -> return E ; next(); call(E); try(type_compare(tmp_ftype, tmp_psitem.type)); if (tmp_psitem.type != tmp_ftype) { try(tmp_var(tmp_ftype, &conv)); generate(I_CONVERT, tmp_psitem.value.ptr, NULL, conv); } else { conv = tmp_psitem.value.ptr; } generate(I_RETURN, conv, NULL, NULL); term(TT_SEMICOLON); return OK; case TT_CIN: // rule: S -> cin >> id IN ; next(); term(TT_IN); check(TT_ID); if (!var_exists(token.p_string)) return ERR_UNDEF; Tlocal_sym_tab_node *var = get_var(token.p_string); generate(I_CIN, NULL, NULL, var); next(); call(IN); term(TT_SEMICOLON); return OK; case TT_COUT: // rule: S -> cout << E OUT ; next(); term(TT_OUT); call(E); generate(I_COUT, tmp_psitem.value.ptr, NULL, NULL); call(OUT); term(TT_SEMICOLON); return OK; default: // rule: S -> E ; call(E); term(TT_SEMICOLON); return OK; } } static int D() { // variable declaration Tdata_type vtype; switch (token.type) { case TT_AUTO: case TT_INT: case TT_DOUBLE: case TT_STRING: // rule: D -> type id I vtype = get_type(); tmp_type = vtype; next(); check(TT_ID); try(add_var(vtype, token.p_string)); try(tmpstr(token.p_string)); next(); return(I); default: return ERR_PARSER; } } static int I() { // variable definition switch (token.type) { case TT_ASSIGN: // rule: I -> = E next(); call(E); try(assign_type_compare(tmp_buffer.str, tmp_psitem.type)); Tlocal_sym_tab_node *var = get_var(tmp_buffer.str); Tlocal_sym_tab_node *conv; if (tmp_psitem.type != var->data_type) { try(tmp_var(var->data_type, &conv)); generate(I_CONVERT, tmp_psitem.value.ptr, NULL, conv); } else { conv = tmp_psitem.value.ptr; } generate(I_ASSIGN, conv, NULL, var); return OK; default: // rule: I -> eps if (tmp_type == TYPE_AUTO) return ERR_AUTO; return OK; } } static int ELSE() { // else switch (token.type) { case TT_ELSE: // rule: ELSE -> else S next(); return(S); default: // rule: ELSE -> eps return OK; } } static int IN() { // input variables switch (token.type) { case TT_IN: // rule: IN -> >> id IN next(); check(TT_ID); if (!var_exists(token.p_string)) return ERR_UNDEF; Tlocal_sym_tab_node *var = get_var(token.p_string); generate(I_CIN, NULL, NULL, var); next(); return(IN); default: // rule: IN -> eps return OK; } } static int OUT() { // output expressions switch (token.type) { case TT_OUT: // rule: OUT -> << E OUT next(); call(E); generate(I_COUT, tmp_psitem.value.ptr, NULL, NULL); return(OUT); default: // rule: OUT -> eps return OK; } } static int E() { // expression Tpsa_stack *psa_stack = ps_init(); ps_push(psa_stack, OP_END); if (get_prec(OP_END) == ' ') { fprintf(stderr, "Syntax error: 'expression' expected, but '%s' given.\n", token_[token.type]); return ERR_PARSER; } int err; do { Tps_item *ps_item = ps_first_term(psa_stack); switch (get_prec(ps_item->op)) { case '=': err = ps_push_token(psa_stack); if (err != OK) { ps_destroy(psa_stack); return err; } next(); break; case '<': err = ps_ins_after(psa_stack, ps_item, OP_EXPR); if (err != OK) { ps_destroy(psa_stack); return err; } err = ps_push_token(psa_stack); if (err != OK) { ps_destroy(psa_stack); return err; } next(); break; case '>': err = psa(psa_stack); if (err != OK) { ps_destroy(psa_stack); return err; } break; } } while (get_prec(ps_first_term(psa_stack)->op) != ' '); Tps_item *top = ps_top(psa_stack); if (top->op != OP_NTERM || ps_prev(psa_stack)->op != OP_END) { fprintf(stderr, "Syntax error: unexpected '%s'\n", token_[token.type]); return ERR_PARSER; } tmp_psitem.type = top->type; tmp_psitem.value = top->value; ps_destroy(psa_stack); return OK; } int parse() { next(); strInit(&tmp_buffer); int err = P(); strFree(&tmp_buffer); return err; }