/* !!! FONCTION INUTILISEE !!! */ void CscVerifUpdown(const UpDownVector *updovct, const SymbolMatrix *symbmtx, const PASTIX_FLOAT *rhs2) { PASTIX_INT itercblk; PASTIX_INT itercol; PASTIX_INT itersm2x; #ifdef CSC_LOG fprintf(stdout, "-> CscVerifUpdown \n"); #endif for (itercblk=0; itercblk<symbmtx->cblknbr; itercblk++) { itersm2x = updovct->cblktab[itercblk].sm2xind; for (itercol=symbmtx->cblktab[itercblk].fcolnum; itercol<symbmtx->cblktab[itercblk].lcolnum+1; itercol++) { #ifdef CPLX errorPrint( "%ld (%10e,%10e) (%10e,%10e)\n", (long)itercol, creal(rhs2[itercol]), cimag(rhs2[itercol]), creal(updovct->sm2xtab[itersm2x]), cimag(updovct->sm2xtab[itersm2x])); #else errorPrint( "%ld %10e %10e\n", (long)itercol, rhs2[itercol], updovct->sm2xtab[itersm2x]); #endif itersm2x++; } } #ifdef CSC_LOG fprintf(stdout, "<- CscVerifUpdown \n"); #endif }
int SCOTCH_graphMapInit ( const SCOTCH_Graph * const grafptr, /*+ Graph to map +*/ SCOTCH_Mapping * const mappptr, /*+ Mapping structure to initialize +*/ const SCOTCH_Arch * const archptr, /*+ Target architecture used to map +*/ SCOTCH_Num * const parttab) /*+ Mapping array +*/ { LibMapping * restrict lmapptr; #ifdef SCOTCH_DEBUG_LIBRARY1 if (sizeof (SCOTCH_Mapping) < sizeof (LibMapping)) { errorPrint ("SCOTCH_graphMapInit: internal error"); return (1); } #endif /* SCOTCH_DEBUG_LIBRARY1 */ lmapptr = (LibMapping *) mappptr; lmapptr->grafptr = (Graph *) grafptr; lmapptr->archptr = (Arch *) archptr; lmapptr->flagval = LIBMAPPINGNONE; /* No options set */ if (parttab == NULL) { if ((lmapptr->parttab = (Gnum *) memAlloc (lmapptr->grafptr->vertnbr * sizeof (Gnum))) == NULL) { errorPrint ("SCOTCH_graphMapInit: out of memory"); return (1); } memSet (lmapptr->parttab, 0, lmapptr->grafptr->vertnbr * sizeof (Anum)); /* All vertices mapped to first domain */ lmapptr->flagval |= LIBMAPPINGFREEPART; /* The user did not provided the partition array, so we will free it */ } else lmapptr->parttab = (Gnum *) parttab; return (0); }
/* * Funktion liesst Kataloge aus */ int loadCatalogs(){ // BROWSE_CMD - Kataloge auflisten if(write(stdinPipe[1], BROWSE_CMD, strlen(BROWSE_CMD)) < strlen(BROWSE_CMD)){ errorPrint("Senden der Nachricht über Pipe fehlgeschlagen: "); return 1; } // Zeilenumbruch if(write(stdinPipe[1], "\n", 1) < 1){ errorPrint("Senden der Nachricht über Pipe fehlgeschlagen: "); return 2; } // Katalogname char* catalogname; // Zaehlvariable fuer Anzahl Kataloge int i = 0; int err = 0; while(err > -1){ // Daten aus dem Leseende von stdoutPipe lesen catalogname = readLine(stdoutPipe[0]); // pruefe ob Zeilenumbruch err = strcmp(catalogname, "\n"); if(err > -1){ // Katalog hinzufuegen addCatalog(catalogname, i); i++; } } infoPrint("Kataloge eingelesen: %i", i); return 0; }
int dgraphAllreduceMaxSum2 ( Gnum * reduloctab, /* Pointer to array of local Gnum data */ Gnum * reduglbtab, /* Pointer to array of reduced Gnum data */ int redumaxsumnbr, /* Number of max + sum Gnum operations */ MPI_User_function * redufuncptr, /* Pointer to operator function */ MPI_Comm proccomm) /* Communicator to be used for reduction */ { MPI_Datatype redutypedat; /* Data type for finding best separator */ MPI_Op reduoperdat; /* Handle of MPI operator for finding best separator */ if ((MPI_Type_contiguous (redumaxsumnbr, GNUM_MPI, &redutypedat) != MPI_SUCCESS) || (MPI_Type_commit (&redutypedat) != MPI_SUCCESS) || (MPI_Op_create (redufuncptr, 1, &reduoperdat) != MPI_SUCCESS)) { errorPrint ("dgraphAllreduceMaxSum: communication error (1)"); return (1); } if (MPI_Allreduce (reduloctab, reduglbtab, 1, redutypedat, reduoperdat, proccomm) != MPI_SUCCESS) { errorPrint ("dgraphAllreduceMaxSum: communication error (2)"); return (1); } if ((MPI_Op_free (&reduoperdat) != MPI_SUCCESS) || (MPI_Type_free (&redutypedat) != MPI_SUCCESS)) { errorPrint ("dgraphAllreduceMaxSum: communication error (3)"); return (1); } return (0); }
int main ( int argc, char * argv[]) { SCOTCH_Arch arch; /* Architecture read and written */ int i; errorProg ("acpl"); if ((argc >= 2) && (argv[1][0] == '?')) { /* If need for help */ usagePrint (stdout, C_usageList); return (0); } fileBlockInit (C_fileTab, C_FILENBR); /* Set default stream pointers */ for (i = 1; i < argc; i ++) { /* Loop for all option codes */ if ((argv[i][0] != '-') || (argv[i][1] == '\0') || (argv[i][1] == '.')) { /* If found a file name */ if (C_fileNum < C_FILEARGNBR) /* File name has been given */ fileBlockName (C_fileTab, C_fileNum ++) = argv[i]; else { errorPrint ("main: too many file names given"); return (1); } } else { /* If found an option name */ switch (argv[i][1]) { case 'H' : /* Give the usage message */ case 'h' : usagePrint (stdout, C_usageList); return (0); case 'V' : fprintf (stderr, "acpl, version " SCOTCH_VERSION_STRING "\n"); fprintf (stderr, "Copyright 2004,2007,2008,2010-2012,2014,2018 IPB, Universite de Bordeaux, INRIA & CNRS, France\n"); fprintf (stderr, "This software is libre/free software under CeCILL-C -- see the user's manual for more information\n"); return (0); default : errorPrint ("main: unprocessed option '%s'", argv[i]); return (1); } } } fileBlockOpen (C_fileTab, C_FILENBR); /* Open all files */ SCOTCH_archInit (&arch); /* Initialize architecture structure */ SCOTCH_archLoad (&arch, C_filepntrtgtinp); /* Load architecture */ if (strcmp (SCOTCH_archName (&arch), "deco") != 0) { /* If not a decomposition */ errorPrint ("main: architecture is not decomposition-defined"); return (1); } SCOTCH_archSave (&arch, C_filepntrtgtout); /* Save the compiled architecture */ fileBlockClose (C_fileTab, C_FILENBR); /* Always close explicitely to end eventual (un)compression tasks */ SCOTCH_archExit (&arch); return (0); }
int SCOTCH_graphMapCompute ( SCOTCH_Graph * const grafptr, /*+ Graph to order +*/ SCOTCH_Mapping * const mappptr, /*+ Mapping to compute +*/ SCOTCH_Strat * const stratptr) /*+ Mapping strategy +*/ { Kgraph mapgrafdat; /* Effective mapping graph */ const Strat * mapstratptr; /* Pointer to mapping strategy */ LibMapping * restrict lmapptr; int o; #ifdef SCOTCH_DEBUG_GRAPH2 if (graphCheck ((Graph *) grafptr) != 0) { errorPrint ("SCOTCH_graphMapCompute: invalid input graph"); return (1); } #endif /* SCOTCH_DEBUG_GRAPH2 */ lmapptr = (LibMapping *) mappptr; if (*((Strat **) stratptr) == NULL) { /* Set default mapping strategy if necessary */ ArchDom archdomnorg; archDomFrst (&lmapptr->m.archdat, &archdomnorg); if (archVar (&lmapptr->m.archdat)) SCOTCH_stratGraphClusterBuild (stratptr, 0, 1, 0.0, 0.05); else SCOTCH_stratGraphMapBuild (stratptr, 0, archDomSize (&lmapptr->m.archdat, &archdomnorg), 0.05); } mapstratptr = *((Strat **) stratptr); if (mapstratptr->tabl != &kgraphmapststratab) { errorPrint ("SCOTCH_graphMapCompute: not a graph mapping strategy"); return (1); } if (kgraphInit (&mapgrafdat, (Graph *) grafptr, &lmapptr->m) != 0) return (1); o = kgraphMapSt (&mapgrafdat, mapstratptr); /* Perform mapping */ lmapptr->m.domnmax = mapgrafdat.m.domnmax; /* Do not free the mapping, as it has been cloned */ lmapptr->m.domnnbr = mapgrafdat.m.domnnbr; lmapptr->m.domntab = mapgrafdat.m.domntab; /* Update pointer to domntab in case it has changed */ mapgrafdat.m.parttax = NULL; /* Prevent mapping arrays from being freed by graph */ mapgrafdat.m.domntab = NULL; kgraphExit (&mapgrafdat); if (lmapptr->parttax != NULL) { /* Propagate mapping data to user partition array */ Gnum vertnum; Gnum vertnnd; for (vertnum = lmapptr->m.baseval, vertnnd = vertnum + lmapptr->m.vertnbr; vertnum < vertnnd; vertnum ++) lmapptr->parttax[vertnum] = archDomNum (&lmapptr->m.archdat, &lmapptr->m.domntab[lmapptr->m.parttax[vertnum]]); } return (o); }
int orderLoad ( Order * const ordeptr, FILE * const stream) { PASTIX_INT versval; /* Version number */ PASTIX_INT cblknbr; PASTIX_INT cblknum; PASTIX_INT vertnbr; PASTIX_INT vertnum; PASTIX_INT vertnnd; PASTIX_INT * permtax; PASTIX_INT * peritax; int i; if ((intLoad (stream, &versval) + intLoad (stream, &cblknbr) + intLoad (stream, &vertnbr) != 3) || (versval != 0) || (cblknbr > vertnbr)) { errorPrint ("orderLoad: bad input (1)"); return (1); } if (((ordeptr->rangtab = (PASTIX_INT *) memAlloc ((cblknbr + 1) * sizeof (PASTIX_INT))) == NULL) || ((ordeptr->permtab = (PASTIX_INT *) memAlloc (vertnbr * sizeof (PASTIX_INT))) == NULL) || ((ordeptr->peritab = (PASTIX_INT *) memAlloc (vertnbr * sizeof (PASTIX_INT))) == NULL)) { errorPrint ("orderLoad: out of memory"); orderExit (ordeptr); orderInit (ordeptr); return (1); } ordeptr->cblknbr = cblknbr; for (cblknum = 0, i = 1; (i == 1) && (cblknum <= cblknbr); cblknum ++) /* Read column-block data */ i = intLoad (stream, &ordeptr->rangtab[cblknum]); for (vertnum = 0; (i == 1) && (vertnum < vertnbr); vertnum ++) /* Read direct permutation */ i = intLoad (stream, &ordeptr->permtab[vertnum]); if (i != 1) { errorPrint ("orderLoad: bad input (2)"); orderExit (ordeptr); orderInit (ordeptr); return (1); } permtax = ordeptr->permtab - ordeptr->rangtab[0]; peritax = ordeptr->peritab - ordeptr->rangtab[0]; for (vertnum = ordeptr->rangtab[0], vertnnd = vertnum + vertnbr; /* Build inverse permutation */ vertnum < vertnnd; vertnum ++) peritax[permtax[vertnum]] = vertnum; return (0); }
int fileBlockOpenDist ( File * const filetab, const int filenbr, const int procglbnbr, const int proclocnum, const int protglbnum) { int i, j; for (i = 0; i < filenbr; i ++) { /* For all file names */ if (fileNameDistExpand (&filetab[i].name, procglbnbr, proclocnum, protglbnum) != 0) { /* If cannot allocate new name */ errorPrint ("fileBlockOpenDist: cannot create file name (%d)", i); return (1); } if (filetab[i].name == NULL) /* If inexisting stream because not root process and centralized stream */ filetab[i].pntr = NULL; if (filetab[i].pntr == NULL) /* If unwanted stream, do nothing */ continue; for (j = 0; j < i; j ++) { if ((filetab[i].mode[0] == filetab[j].mode[0]) && /* If very same name with same opening mode */ (filetab[j].name != NULL) && (strcmp (filetab[i].name, filetab[j].name) == 0)) { filetab[i].pntr = filetab[j].pntr; /* Share pointer to already processed stream */ filetab[i].name = NULL; /* Do not close this stream multiple times */ break; } } if (j == i) { /* If original stream */ int compval; /* Compression type */ FILE * compptr; /* Processed ((un)compressed) stream */ if (filetab[i].name[0] != '-') { /* If not standard stream, open it */ if ((filetab[i].pntr = fopen (filetab[i].name, filetab[i].mode)) == NULL) { /* Open the file */ errorPrint ("fileBlockOpenDist: cannot open file (%d)", i); return (1); } } compval = (filetab[i].mode[0] == 'r') ? fileUncompressType (filetab[i].name) : fileCompressType (filetab[i].name); if (compval < 0) { errorPrint ("fileBlockOpenDist: (un)compression type not implemented"); return (1); } compptr = (filetab[i].mode[0] == 'r') ? fileUncompress (filetab[i].pntr, compval) : fileCompress (filetab[i].pntr, compval); if (compptr == NULL) { errorPrint ("fileBlockOpenDist: cannot create (un)compression subprocess"); return (1); } filetab[i].pntr = compptr; /* Use processed stream instead of original stream */ } } return (0); }
static bool execInternal(const char *stmt, int mode) { bool notfound = false; newStatement(); if(!prepareInternal(stmt)) return false; /* error */ if(!rv_numRets) { if(!(mode & 1)) { showStatement(); errorPrint("2SQL select statement returns no values"); } notfound = true; } else { /* end no return values */ if(!(mode & 2)) { showStatement(); errorPrint("2SQL statement returns %d values", rv_numRets); } } if(!openfirst) rc = SQLExecute(hstmt); if(!rc) { /* statement succeeded */ /* fetch the data, or get a count of the rows affected */ if(rv_numRets) { stmt_text = "fetch"; debugStatement(); rc = SQLFetchScroll(hstmt, (ushort) SQL_FD_FETCH_NEXT, 1); if(rc == SQL_NO_DATA) { rc = SQL_SUCCESS; notfound = true; } else everything_null = false; } else { rc = SQLRowCount(hstmt, &rv_lastNrows); if(sql_debug) appendFile(sql_debuglog, "%d rows affected", rv_lastNrows); if(sql_debug2) printf("%d rows affected\n", rv_lastNrows); } } if(errorTrap(0)) return false; if(!rv_numRets) return true; return !notfound; } /* execInternal */
int SCOTCH_dgraphGather ( const SCOTCH_Dgraph * const dgrfptr, SCOTCH_Graph * const cgrfptr) { Dgraph * restrict srcdgrfptr; Gnum reduloctab[3]; Gnum reduglbtab[3]; srcdgrfptr = (Dgraph *) dgrfptr; if ((cgrfptr != NULL) && (((void *) cgrfptr) != ((void *) dgrfptr))) { /* If centralized graph provided */ reduloctab[0] = 1; /* Process is a potential root */ reduloctab[1] = (Gnum) srcdgrfptr->proclocnum; } else { /* Process is not a root */ reduloctab[0] = 0; reduloctab[1] = 0; } if (srcdgrfptr->edloloctax == NULL) /* Compute sum of edge loads for access to low-level routines */ reduloctab[2] = srcdgrfptr->edgelocnbr; else { Gnum vertlocnum; Gnum edlolocsum; for (vertlocnum = srcdgrfptr->baseval, edlolocsum = 0; vertlocnum < srcdgrfptr->vertlocnnd; vertlocnum ++) { Gnum edgelocnum; Gnum edgelocnnd; for (edgelocnum = srcdgrfptr->vertloctax[vertlocnum], edgelocnnd = srcdgrfptr->vendloctax[vertlocnum]; edgelocnum < edgelocnnd; edgelocnum ++) edlolocsum += srcdgrfptr->edloloctax[edgelocnum]; } reduloctab[2] = edlolocsum; } if (MPI_Allreduce (reduloctab, reduglbtab, 3, GNUM_MPI, MPI_SUM, srcdgrfptr->proccomm) != MPI_SUCCESS) { errorPrint ("SCOTCH_dgraphGather: communication error"); return (1); } if (reduglbtab[0] == 1) /* If only one single root */ return (dgraphGatherAll2 (srcdgrfptr, (Graph *) cgrfptr, reduglbtab[2], (int) reduglbtab[1])); else if (reduglbtab[0] == srcdgrfptr->procglbnbr) /* If all processes are roots */ return (dgraphGatherAll2 (srcdgrfptr, (Graph *) cgrfptr, reduglbtab[2], -1)); errorPrint ("SCOTCH_dgraphGather: invalid number of roots"); return (1); }
int SCOTCH_dgraphBuild ( SCOTCH_Dgraph * const grafptr, /* Distributed graph structure to fill */ const Gnum baseval, /* Base for indexing */ const Gnum vertlocnbr, /* Number of local vertices */ const Gnum vertlocmax, /* Maximum number of local vertices */ Gnum * const vertloctab, /* Local vertex begin array */ Gnum * const vendloctab, /* Local vertex end array */ Gnum * const veloloctab, /* Local vertex load array (if any) */ Gnum * const vlblloctab, /* Local vertex label array (if any) */ const Gnum edgelocnbr, /* Number of local edges */ const Gnum edgelocsiz, /* Size of local edge array */ Gnum * const edgeloctab, /* Local edge array */ Gnum * const edgegsttab, /* Ghost edge array (if any); not const */ Gnum * const edloloctab) /* Local edge load array (if any) */ { Dgraph * srcgrafptr; /* Pointer to source graph structure */ Gnum * vertloctax; Gnum * vendloctax; Gnum * veloloctax; Gnum * vlblloctax; Gnum * edgeloctax; Gnum * edgegsttax; Gnum * edloloctax; #ifdef SCOTCH_DEBUG_LIBRARY1 if (sizeof (SCOTCH_Dgraph) < sizeof (Dgraph)) { errorPrint (STRINGIFY (SCOTCH_dgraphBuild) ": internal error"); return (1); } #endif /* SCOTCH_DEBUG_LIBRARY1 */ if ((baseval < 0) || (baseval > 1)) { errorPrint (STRINGIFY (SCOTCH_dgraphBuild) ": invalid base parameter"); return (1); } srcgrafptr = (Dgraph *) grafptr; /* Use structure as source graph */ vertloctax = (Gnum *) vertloctab - baseval; vendloctax = ((vendloctab == NULL) || (vendloctab == vertloctab + 1)) ? vertloctax + 1 : (Gnum *) vendloctab - baseval; veloloctax = ((veloloctab == NULL) || (veloloctab == vertloctab)) ? NULL : (Gnum *) veloloctab - baseval; vlblloctax = ((vlblloctab == NULL) || (vlblloctab == vertloctab)) ? NULL : (Gnum *) vlblloctab - baseval; edgeloctax = (Gnum *) edgeloctab - baseval; edgegsttax = ((edgegsttab == NULL) || (edgegsttab == edgeloctab)) ? NULL : (Gnum *) edgegsttab - baseval; edloloctax = ((edloloctab == NULL) || (edloloctab == edgeloctab)) ? NULL : (Gnum *) edloloctab - baseval; return (dgraphBuild (srcgrafptr, baseval, vertlocnbr, vertlocmax, vertloctax, vendloctax, veloloctax, NULL, vlblloctax, edgelocnbr, edgelocsiz, edgeloctax, edgegsttax, edloloctax)); }
/* dereference an existing cursor */ static struct OCURS * findCursor(int cid) { struct OCURS *o; if(cid < 6000 || cid >= 6000 + NUMCURSORS) errorPrint("2cursor number %d is out of range", cid); cid -= 6000; o = ocurs + cid; if(o->flag == CURSOR_NONE) errorPrint("2cursor %d is not currently active", cid + 6000); rv_numRets = o->numrets; memcpy(rv_type, o->rv_type, NUMRETS); return o; } /* findCursor */
void connect_socket_client(int *sock, char serv_addr[], char port[]){ struct addrinfo *addr_info, *p, hints; int ret; /**Set the socket at the beginning to -1 and change value if connection works!*/ memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; hints.ai_flags = 0 /** | AI_ADDRCONFIG */; /**RTFM: getaddrinfo */ ret = getaddrinfo(serv_addr, port, &hints, &addr_info); if (ret){ errorPrint("getaddrinfo: %s", gai_strerror(ret)); exit(1); } p = addr_info; while (p){ char dst[INET6_ADDRSTRLEN]; /**Create socket for found family */ *sock = socket(p->ai_family, p->ai_socktype, 0); /**RTFM: getnameinfo */ getnameinfo(p->ai_addr, p->ai_addrlen, dst, sizeof(dst), NULL, 0, NI_NUMERICHOST); /**Try to connect */ if (connect(*sock, p->ai_addr, p->ai_addrlen) == 0){ infoPrint("Connected"); break; }else{ errorPrint("Error, while trying %s",dst); } p = p->ai_next; } freeaddrinfo(addr_info); }
int SCOTCH_geomInit ( SCOTCH_Geom * const geomptr) { if (sizeof (SCOTCH_Num) != sizeof (Gnum)) { errorPrint (STRINGIFY (SCOTCH_geomInit) ": internal error (1)"); return (1); } if (sizeof (SCOTCH_Geom) < sizeof (Geom)) { errorPrint (STRINGIFY (SCOTCH_geomInit) ": internal error (2)"); return (1); } return (geomInit ((Geom *) geomptr)); }
int orderSave ( const Order * const ordeptr, FILE * const stream) { PASTIX_INT vertnbr; PASTIX_INT vertnum; PASTIX_INT cblknum; int o; if (ordeptr->rangtab == NULL) { errorPrint ("orderSave: cannot save ordering without column block data"); return (1); } if (ordeptr->permtab == NULL) { errorPrint ("orderSave: cannot save ordering without direct permutation data"); return (1); } vertnbr = ordeptr->rangtab[ordeptr->cblknbr] - /* Get number of nodes */ ordeptr->rangtab[0]; if (fprintf (stream, "0\n%ld\t%ld\n", (long) ordeptr->cblknbr, (long) vertnbr) == EOF) { errorPrint ("orderSave: bad output (1)"); return (1); } for (cblknum = 0, o = 1; (o == 1) && (cblknum < ordeptr->cblknbr); cblknum ++) { /* Save column-block range array */ o = intSave (stream, ordeptr->rangtab[cblknum]); putc (((cblknum & 7) == 7) ? '\n' : '\t', stream); } o = intSave (stream, ordeptr->rangtab[cblknum]); putc ('\n', stream); for (vertnum = 0; (o == 1) && (vertnum < (vertnbr - 1)); vertnum ++) { /* Save direct permutation */ o = intSave (stream, ordeptr->permtab[vertnum]); putc (((vertnum & 7) == 7) ? '\n' : '\t', stream); } o = intSave (stream, ordeptr->permtab[vertnum]); putc ('\n', stream); if (o != 1) errorPrint ("orderSave: bad output (2)"); return (1 - o); }
//------------------------------------------------------------ // initList() //------------------------------------------------------------ int initList(char *name) { try { createdL68 = false; listFile = fopen(name, "w"); if (!listFile) { sprintf(buffer,"Unable to create listing file"); // TODO: (GUI) Send error to GUI errorPrint(buffer); return MILD_ERROR; } // Current time as a string for use in timestamp for listfile. time_t now = time(NULL); char *timeStr = ctime(&now); // Reserve room for starting address fprintf(listFile, "00000000 Starting Address\n"); // Assembler Info and Timestamp fprintf(listFile, "Assembler used: %s\n", TITLE); fprintf(listFile, "Created On: %s\n\n", timeStr); createdL68 = true; return NORMAL; } catch( ... ) { sprintf(buffer, "ERROR: An exception occurred in routine 'initList'. \n"); printError(NULL, EXCEPTION, 0); return MILD_ERROR; } }
//------------------------------------------------------------ // listObj //------------------------------------------------------------ int listObj(int data, int size) { if (!CEXflag && (listPtr - listData + size > 31)) { strcpy(listData + ((size == WORD_SIZE) ? 26 : 28), "..."); return NORMAL; } if (CEXflag && (listPtr - listData + size > 31)) { listLine(line); strcpy(listData, " "); listPtr = listData + 10; continuation = true; } switch (size) { case BYTE_SIZE_M: sprintf(listPtr, "%02X ", data & 0xFF); listPtr += 3; break; case WORD_SIZE: sprintf(listPtr, "%04X ", data & 0xFFFF); listPtr += 5; break; // TODO: (WORKAROUND) Make sure casting data as (unsigned long) isn't a bad workaround // NOTE: IT WAS! case LONG_SIZE: sprintf(listPtr, "%08lX ", data); listPtr += 9; break; default: sprintf(buffer,"LISTOBJ: INVALID SIZE CODE!\n"); // TODO: (GUI) Send error message to document window errorPrint(buffer); return MILD_ERROR; } return NORMAL; }
static void newStatement(void) { rc = SQLAllocStmt(hdbc, &hstmt); if(rc) errorPrint("@could not alloc singleton ODBC statement handle"); } /* newStatement */
void sopalin_launch_comm(int nbthrdcomm, void * (*comm_routine)(void *), void *data) { int ret, i; pthread_t *calltab = NULL; sopthread_data_t *d = NULL; MALLOC_INTERN(calltab, nbthrdcomm, pthread_t); MALLOC_INTERN(d, nbthrdcomm, sopthread_data_t); for (i=0;i<nbthrdcomm;i++) { pthread_attr_t attr; pthread_attr_init(&attr); d[i].me = -1-i; d[i].data = data; ret = pthread_create(&calltab[i],&attr,comm_routine,(void *)&d[i]); if (ret) {errorPrint("thread create."); EXIT(MOD_SOPALIN,THREAD_ERR);} } for (i=0; i<nbthrdcomm; i++) pthread_detach(calltab[i]); memFree_null(calltab); /* memFree_null(d);*/ }
void gainTablAddLin ( GainTabl * const tablptr, /*+ Pointer to gain table +*/ GainLink * const linkptr, /*+ Pointer to entry to add +*/ const INT gain) /*+ Gain value +*/ { GainEntr * entrptr; /* Pointer to gain entry */ GainLink * headptr; /* Pointer to head of list */ #ifdef SCOTCH_DEBUG_GAIN2 if (tablptr->tablAdd != gainTablAddLin) { errorPrint ("gainTablAddLin: table type mismatch"); return; } #endif /* SCOTCH_DEBUG_GAIN2 */ entrptr = tablptr->tabl + gain; if (entrptr < tablptr->tabk) entrptr = tablptr->tabk; else if (entrptr > tablptr->tend) entrptr = tablptr->tend; if (entrptr < tablptr->tmin) tablptr->tmin = entrptr; if (entrptr > tablptr->tmax) tablptr->tmax = entrptr; headptr = (GainLink *) entrptr; /* TRICK: assume gain entry is a link */ linkptr->tabl = entrptr; /* Set table position */ headptr->next->prev = linkptr; /* Link vertex in gain list: TRICK */ linkptr->prev = headptr; linkptr->next = headptr->next; headptr->next = linkptr; }
/* * Function: PASTIX_potrf * * Factorization LLt BLAS2 3 terms * * > A = LL^T * * Parameters: * A - Matrix to factorize * n - Size of A * stride - Stide between 2 columns of the matrix * nbpivot - IN/OUT pivot number. * critere - Pivoting threshold. * */ void PASTIX_potrf (PASTIX_FLOAT * A, PASTIX_INT n, PASTIX_INT stride, PASTIX_INT *nbpivot, double critere) { PASTIX_INT k; PASTIX_FLOAT *tmp,*tmp1; for (k=0;k<n;k++) { tmp=A+k* (stride+1); #ifdef USE_CSC if (ABS_FLOAT(*tmp)<critere) { (*tmp) = (PASTIX_FLOAT)critere; (*nbpivot)++; } #endif #ifdef TYPE_COMPLEX *tmp = (PASTIX_FLOAT)csqrt(*tmp); #else *tmp = (PASTIX_FLOAT)sqrt(*tmp); if (*tmp < 0) { errorPrint ("Negative diagonal term\n"); EXIT (MOD_SOPALIN, INTERNAL_ERR); } #endif tmp1=tmp+1; SOPALIN_SCAL (n-k-1,(fun/(*tmp)),tmp1,iun); SOPALIN_SYR ("L",n-k-1,-fun,tmp1,iun,tmp1+stride,stride); } }
/* * Function: updo_trsm_starpu_common * * Parameters: * buffers - Data handlers : * 1 - L column block * 2 - Right-hand-side block facing the column block. * _args - Codelet arguments: * sopalin_data - global PaStiX internal data. * cblknum - Current column block index. */ static inline void updo_trsm_starpu_common(void * buffers[], void * _args, int arch) { starpu_updo_trsm_data_t * args = (starpu_updo_trsm_data_t*)_args; Sopalin_Data_t * sopalin_data = args->sopalin_data; SolverMatrix * datacode = sopalin_data->datacode; PASTIX_FLOAT * L = (PASTIX_FLOAT*)STARPU_MATRIX_GET_PTR(buffers[0]); PASTIX_FLOAT * RHS = (PASTIX_FLOAT*)STARPU_MATRIX_GET_PTR(buffers[1]); PASTIX_INT stride = STARPU_MATRIX_GET_LD(buffers[0]); PASTIX_INT rhsnbr = STARPU_MATRIX_GET_NY(buffers[1]); PASTIX_INT rhssze = STARPU_MATRIX_GET_LD(buffers[1]); PASTIX_INT cblknum = args->cblknum; char * transpose = &(args->transpose); char * diag = &(args->diag); PASTIX_INT colnbr = CBLK_COLNBR(cblknum); PASTIX_FLOAT fun = 1.0; ASSERTDBG(UPDOWN_SM2XNBR == rhsnbr, MOD_SOPALIN); ASSERTDBG(UPDOWN_SM2XSZE == rhssze, MOD_SOPALIN); switch(arch) { case ARCH_CPU: SOPALIN_TRSM("L","L",transpose,diag,colnbr,rhsnbr,fun,L,stride,RHS,rhssze); break; case ARCH_CUDA: default: errorPrint("Unknown Architecture"); assert(0); break; } }
int SCOTCH_graphOrderInit ( const SCOTCH_Graph * const grafptr, /*+ Graph to order +*/ SCOTCH_Ordering * const ordeptr, /*+ Ordering structure to initialize +*/ SCOTCH_Num * const permtab, /*+ Direct permutation array +*/ SCOTCH_Num * const peritab, /*+ Inverse permutation array +*/ SCOTCH_Num * const cblkptr, /*+ Pointer to number of column blocks +*/ SCOTCH_Num * const rangtab, /*+ Column block range array +*/ SCOTCH_Num * const treetab) /*+ Separator tree array +*/ { Graph * srcgrafptr; LibOrder * libordeptr; #ifdef SCOTCH_DEBUG_LIBRARY1 if (sizeof (SCOTCH_Ordering) < sizeof (LibOrder)) { errorPrint ("SCOTCH_graphOrderInit: internal error"); return (1); } #endif /* SCOTCH_DEBUG_LIBRARY1 */ srcgrafptr = (Graph *) grafptr; /* Use structure as source graph */ libordeptr = (LibOrder *) ordeptr; libordeptr->permtab = ((permtab == NULL) || ((void *) permtab == (void *) grafptr)) ? NULL : (Gnum *) permtab; libordeptr->peritab = ((peritab == NULL) || ((void *) peritab == (void *) grafptr)) ? NULL : (Gnum *) peritab; libordeptr->cblkptr = ((cblkptr == NULL) || ((void *) cblkptr == (void *) grafptr)) ? NULL : (Gnum *) cblkptr; libordeptr->rangtab = ((rangtab == NULL) || ((void *) rangtab == (void *) grafptr)) ? NULL : (Gnum *) rangtab; libordeptr->treetab = ((treetab == NULL) || ((void *) treetab == (void *) grafptr)) ? NULL : (Gnum *) treetab; return (orderInit (&libordeptr->o, srcgrafptr->baseval, srcgrafptr->vertnbr, libordeptr->peritab)); }
bool IniParser::parse(FILE *f) { in = f; if (in==0) { errorPrint("%s: %s", filename, strerror( errno )); return false; } nextToken(); while (!feof(in)) { if (strcmp(buffer, "[") ==0) { if (!readNextSection()) { printError("failed to read section"); fclose(in); in=0; return false; } } else { printError("expecting '['"); fclose(in); in=0; return false; } } fclose(in); in=0; return true; }
void IniParser::printError(const char *err) { errorPrint("%s:%d:%d (%s) %s\n", filename, line, col, buffer, err); }
int SCOTCH_dgraphMapCompute ( SCOTCH_Dgraph * const grafptr, /*+ Graph to map +*/ SCOTCH_Dmapping * const mappptr, /*+ Mapping to compute +*/ SCOTCH_Strat * const stratptr) /*+ Mapping strategy +*/ { Kdgraph mapgrafdat; /* Effective mapping graph */ Kdmapping mapmappdat; /* Initial mapping domain */ const Strat * mapstratptr; /* Pointer to mapping strategy */ LibDmapping * restrict srcmappptr; Dgraph * srcgrafptr; int o; srcgrafptr = (Dgraph *) grafptr; srcmappptr = (LibDmapping *) mappptr; #ifdef SCOTCH_DEBUG_DGRAPH2 if (dgraphCheck (srcgrafptr) != 0) { errorPrint ("SCOTCH_dgraphMapCompute: invalid input graph"); return (1); } #endif /* SCOTCH_DEBUG_DGRAPH2 */ if (*((Strat **) stratptr) == NULL) { /* Set default mapping strategy if necessary */ ArchDom archdomnorg; archDomFrst (&srcmappptr->m.archdat, &archdomnorg); SCOTCH_stratDgraphMapBuild (stratptr, SCOTCH_STRATQUALITY, srcgrafptr->procglbnbr, archDomSize (&srcmappptr->m.archdat, &archdomnorg), 0.01); } mapstratptr = *((Strat **) stratptr); if (mapstratptr->tabl != &kdgraphmapststratab) { errorPrint ("SCOTCH_dgraphMapCompute: not a parallel graph mapping strategy"); return (1); } if (kdgraphInit (&mapgrafdat, srcgrafptr, &srcmappptr->m) != 0) return (1); mapmappdat.mappptr = &srcmappptr->m; if (((o = kdgraphMapSt (&mapgrafdat, &mapmappdat, mapstratptr)) == 0) && /* Perform mapping */ (srcmappptr->termloctab != NULL)) o = dmapTerm (&srcmappptr->m, &mapgrafdat.s, srcmappptr->termloctab); /* Use "&mapgrafdat.s" to take advantage of ghost arrays */ kdgraphExit (&mapgrafdat); return (o); }
SCOTCH_Num _SCOTCHTdomWght ( const void * const arch, const void * const dom) { errorPrint ("T_domWghtMord: internal error"); return (1); }
int dofGraph ( Dof * const deofptr, /*+ DOF index array to build [based] +*/ const SCOTCH_Graph * const grafptr, /*+ Matrix adjacency structure [based] +*/ const PASTIX_INT deofval, /*+ DOFs per node if no graph vertex load array +*/ const PASTIX_INT * const peritab) /*+ Inverse vertex->node permutation array +*/ { PASTIX_INT baseval; PASTIX_INT vertnbr; PASTIX_INT * velotab; PASTIX_INT edgenbr; (void)peritab; SCOTCH_graphData (grafptr, (SCOTCH_Num *) &baseval, (SCOTCH_Num *) &vertnbr, NULL, NULL, (SCOTCH_Num **)&velotab, NULL, (SCOTCH_Num *) &edgenbr, NULL, NULL); deofptr->baseval = baseval; deofptr->nodenbr = vertnbr; if (velotab == NULL) { /* If no vertex weight (i.e. DOF) array */ deofptr->noddtab = NULL; /* No DOF array */ deofptr->noddval = deofval; /* Get node DOF value */ } else { /* Vertex load array present */ #ifdef DOF_CONSTANT deofptr->noddtab = NULL; /* No DOF array */ deofptr->noddval = deofval; #else /* DOF_CONSTANT */ const PASTIX_INT * restrict velotax; /* Based access to grafptr->velotab */ PASTIX_INT nodenum; /* Number of current node */ PASTIX_INT * noddtnd; /* Pointer to end of DOF index array */ PASTIX_INT * noddptr; /* Pointer to current DOF index */ const PASTIX_INT * periptr; deofptr->noddval = 0; /* DOF values are not constant */ if ((deofptr->noddtab = (PASTIX_INT *) memAlloc ((vertnbr + 1) * sizeof (PASTIX_INT))) == NULL) { errorPrint ("dofGraph: out of memory"); return (1); } for (noddptr = deofptr->noddtab, noddtnd = noddptr + vertnbr, periptr = peritab, nodenum = baseval, velotax = grafptr->velotab - baseval; noddptr < noddtnd; noddptr ++, periptr ++) { *noddptr = nodenum; /* Set index to DOF array */ nodenum += velotax[*periptr]; /* Add number of DOFs for vertex */ } *noddptr = nodenum; /* Set end of DOF array */ #endif /* DOF_CONSTANT */ } return (0); }
int sparse_gemm_cpu( char * transa, char * transb, int m, int n, int k, PASTIX_FLOAT alpha, const PASTIX_FLOAT * a, int lda, const PASTIX_FLOAT * b, int ldb, PASTIX_FLOAT beta, PASTIX_FLOAT * c, unsigned int ldc, int blocknbr, const int * blocktab, int fblocknbr, const int * fblocktab, PASTIX_FLOAT *work, int worksize) { int col; int C_index = 0; int W_index = 0; const int * fblock; const int * lfblock = &(fblocktab[2*(fblocknbr-1)]); const int * block; const int * lblock = &(blocktab[2*(blocknbr-1)]); (void)worksize; SOPALIN_GEMM( transa, transb, m, n, k, alpha, a, lda, b, ldb, 0., work, m); for (block = blocktab, fblock = fblocktab; block <= lblock; W_index += block[1]-block[0]+1, block+=2) { int size; while ((!(block[0] >= fblock[0] && block[1] <= fblock[1])) && lfblock >= fblock) { C_index += fblock[1]-fblock[0]+1; fblock+=2; } if (lfblock < fblock) { errorPrint("block [%d, %d] not found in facing column.", block[0], block[1]); return BADPARAMETER_ERR; } size = block[1]-block[0]+1; /* fprintf(stdout, "%d %d %d %g %d\n", C_index, block[0], fblock[0], work[W_index], size); */ /* fprintf(stdout, "%g\n", c[C_index + block[0]-fblock[0]]); */ for (col = 0; col < n; col++) SOPALIN_SCAL(size, beta, &(c[C_index + block[0]-fblock[0] + col*ldc]), 1); SOPALIN_GEAM("N", "N", size, n, 1.0, &(work[W_index]), m, &(c[C_index + block[0]-fblock[0]]), ldc); /* fprintf(stdout, "%g\n", c[C_index + block[0]-fblock[0]]); */ } return NO_ERR; }
SCOTCH_Num _SCOTCHTdomDist ( const void * const arch, const void * const dom0, const void * const dom1) { errorPrint ("T_domDistMord: internal error"); return (1); }