/* copy a resource from the input file to the output file */ static void copyres(osfildef *fpin, osfildef *fpout, ulong siz, uint endpos_ofs) { ulong startpos; ulong endpos; uchar buf[4]; /* note the starting position */ startpos = osfpos(fpout); /* copy the bytes of the resource */ copybytes(fpin, fpout, siz); /* note the ending position */ endpos = osfpos(fpout); /* write the ending position at the appropriate point */ osfseek(fpout, (ulong)(startpos + endpos_ofs), OSFSK_SET); oswp4(buf, endpos); if (osfwb(fpout, buf, 4)) errexit("error writing resource", 1); /* seek back to the end of the output file */ osfseek(fpout, endpos, OSFSK_SET); }
static void getsummaryinfo(void) { size_t size; int failed; int asked; int i, j; caddr_t sip; /* * read in the summary info. */ sblock.fs_u.fs_csp = calloc(1, sblock.fs_cssize); if (sblock.fs_u.fs_csp == NULL) errexit( "cannot allocate %u bytes for cylinder group summary info\n", (unsigned)sblock.fs_cssize); sip = (caddr_t)sblock.fs_u.fs_csp; asked = 0; for (i = 0, j = 0; i < sblock.fs_cssize; i += sblock.fs_bsize, j++) { size = sblock.fs_cssize - i < sblock.fs_bsize ? sblock.fs_cssize - i : sblock.fs_bsize; failed = fsck_bread(fsreadfd, sip, fsbtodb(&sblock, sblock.fs_csaddr + j * sblock.fs_frag), size); if (failed && !asked) { pfatal("BAD SUMMARY INFORMATION"); if (reply("CONTINUE") == 0) { ckfini(); exit(EXFNDERRS); } asked = 1; } sip += size; } }
void ckfini() { struct bufarea *bp, *nbp; int cnt = 0; for (bp = bufhead.b_prev; bp && bp != &bufhead; bp = nbp) { cnt++; flush(fswritefd, bp); nbp = bp->b_prev; free(bp->b_un.b_buf); free((char *)bp); } pbp = pdirbp = NULL; if (bufhead.b_size != cnt) errexit(gettext("Panic: lost %d buffers\n"), bufhead.b_size - cnt); if (debug) (void) printf("cache missed %ld of %ld (%ld%%)\n", diskreads, totalreads, totalreads ? diskreads * 100 / totalreads : 0); (void) close(fsreadfd); (void) close(fswritefd); }
void remove_all_bonds_to(int identity) { Cell *cell; int p, np, c; Particle *part; for (c = 0; c < local_cells.n; c++) { cell = local_cells.cell[c]; np = cell->n; part = cell->part; for (p = 0; p < np; p++) { IntList *bl = &part[p].bl; int i, j, partners; for (i = 0; i < bl->n;) { partners = bonded_ia_params[bl->e[i]].num; for(j = 1; j <= partners; j++) if (bl->e[i + j] == identity) break; if (j <= partners) { bl->n -= 1 + partners; memcpy(bl->e + i, bl->e + i + 1 + partners, sizeof(int)*(bl->n - i)); realloc_intlist(bl, bl->n); } else i += 1 + partners; } if (i != bl->n) { fprintf(stderr, "%d: INTERNAL ERROR: bond information corrupt for particle %d, exiting...\n", this_node, part[p].p.identity); errexit(); } } } }
void add_forces_from_recv_buffer(GhostCommunication *gc) { int pl, p, np; Particle *part, *pt; char *retrieve; /* put back data */ retrieve = r_buffer; for (pl = 0; pl < gc->n_part_lists; pl++) { np = gc->part_lists[pl]->n; part = gc->part_lists[pl]->part; for (p = 0; p < np; p++) { pt = &part[p]; add_force(&pt->f, (ParticleForce *)retrieve); retrieve += sizeof(ParticleForce); } } if (retrieve - r_buffer != n_r_buffer) { fprintf(stderr, "%d: recv buffer size %d differs " "from what I put in %ld\n", this_node, n_r_buffer, retrieve - r_buffer); errexit(); } }
static struct xyz backtrack(int *tick, bool *cleared_exit, struct course **cend, struct frame **lfrend) { --*tick; struct course *prev = (*cend)->prev; if (prev == NULL) { struct xyz pos = (*cend)->pos; errexit('x', "Aieee. Plane at (%d, %d, %d) is impossible.", pos.row, pos.col, pos.alt); } struct xyz rv = prev->pos; *cleared_exit = prev->cleared_exit; free(*cend); *cend = prev; prev->next = NULL; struct frame *fr = *lfrend; *lfrend = fr->prev; (*lfrend)->next = NULL; free_op_courses(fr->opc_start); free(fr); return rv; }
/*------------------------------------------------------------------------ * TCPecho - send input to ECHO service on specified host and print reply *------------------------------------------------------------------------ */ int TCPecho(const char *host, const char *service) { char buf[LINELEN+1]; /* buffer for one line of text */ int s, n; /* socket descriptor, read count*/ int outchars, inchars; /* characters sent and received */ s = connectTCP(host, service); while (fgets(buf, sizeof(buf), stdin)) { buf[LINELEN] = '\0'; /* insure line null-terminated */ outchars = strlen(buf); (void) send(s, buf, outchars, 0); /* read it back */ for (inchars = 0; inchars < outchars; inchars+=n ) { n = recv(s, &buf[inchars], outchars - inchars, 0); if (n < 0) errexit("socket read failed: %s\n", strerror(errno)); } fputs(buf, stdout); } }
static void copybytes(osfildef *fpin, osfildef *fpout, ulong siz) { uint cursiz; /* copy bytes until we run out */ while (siz != 0) { /* we can copy up to one full buffer at a time */ cursiz = (siz > sizeof(copybuf) ? sizeof(copybuf) : siz); /* deduct the amount we're copying from the total */ siz -= cursiz; /* read from input, copy to output */ if (osfrb(fpin, copybuf, cursiz) || osfwb(fpout, copybuf, cursiz)) { /* error - close files and display an error */ osfcls(fpin); osfcls(fpout); errexit("error copying resource", 1); } } }
static int Zoltan_PHG_Redistribute_Hypergraph( ZZ *zz, PHGPartParams *hgp, /* Input: parameters; used only for UseFixedVtx */ HGraph *ohg, /* Input: Local part of distributed hypergraph */ int firstproc, /* Input: rank (in ocomm) of the first proc of the ncomm*/ int *v2Col, /* Input: Vertex to processor Column Mapping */ int *n2Row, /* Input: Net to processor Row Mapping */ PHGComm *ncomm, /* Input: communicators of new distribution */ HGraph *nhg, /* Output: Newly redistributed hypergraph */ int **vmap, /* Output: allocated with the size nhg->nVtx and vertex map from nhg to ohg's local vertex number*/ int **vdest /* Output: allocated with the size nhg->nVtx and stores dest proc in ocomm */ ) { char * yo = "Zoltan_PHG_Redistribute_Hypergraph"; PHGComm *ocomm = ohg->comm; int ierr=ZOLTAN_OK; int i, v, n, nPins, nsend, elemsz, nVtx, nEdge; int msg_tag = 9999; int *proclist=NULL, *sendbuf=NULL; int *vno=NULL, *nno=NULL, *dist_x=NULL, *dist_y=NULL, *vsn=NULL, *nsn=NULL, *pins=NULL, *cnt=NULL; ZOLTAN_COMM_OBJ *plan; Zoltan_HG_HGraph_Init (nhg); nhg->comm = ncomm; nhg->dist_x = (int *) ZOLTAN_CALLOC(ncomm->nProc_x+1, sizeof(int)); nhg->dist_y = (int *) ZOLTAN_CALLOC(ncomm->nProc_y+1, sizeof(int)); dist_x = (int *) ZOLTAN_CALLOC(ncomm->nProc_x+1, sizeof(int)); dist_y = (int *) ZOLTAN_CALLOC(ncomm->nProc_y+1, sizeof(int)); vsn = (int *) ZOLTAN_CALLOC(ncomm->nProc_x+1, sizeof(int)); nsn = (int *) ZOLTAN_CALLOC(ncomm->nProc_y+1, sizeof(int)); vno = (int *) ZOLTAN_MALLOC(ohg->nVtx * sizeof(int)); nno = (int *) ZOLTAN_MALLOC(ohg->nEdge * sizeof(int)); if (!nhg->dist_x || !nhg->dist_y || !dist_x || !dist_y || !vsn || !nsn || (ohg->nVtx && !vno) || (ohg->nEdge && !nno) ) { uprintf(ocomm, " new comm nProcx=%d nProcy=%d nvtx=%d nedge=%d", ncomm->nProc_x, ncomm->nProc_y, ohg->nVtx, ohg->nEdge); MEMORY_ERROR; } for (v = 0; v < ohg->nVtx; ++v) ++dist_x[v2Col[v]]; for (n = 0; n < ohg->nEdge; ++n) ++dist_y[n2Row[n]]; /* UVCUVC: CHECK ASSUMPTION This code assumes that the objects in the receive buffer of Zoltan_Comm_Do function are 1- in the increasing processor order, 2- order of the items send by a processor is preserved. */ /* compute prefix sum to find new vertex start numbers; for each processor */ MPI_Scan(dist_x, vsn, ncomm->nProc_x, MPI_INT, MPI_SUM, ocomm->row_comm); /* All reduce to compute how many each processor will have */ MPI_Allreduce(dist_x, &(nhg->dist_x[1]), ncomm->nProc_x, MPI_INT, MPI_SUM, ocomm->row_comm); nhg->dist_x[0] = 0; for (i=1; i<=ncomm->nProc_x; ++i) nhg->dist_x[i] += nhg->dist_x[i-1]; MPI_Scan(dist_y, nsn, ncomm->nProc_y, MPI_INT, MPI_SUM, ocomm->col_comm); MPI_Allreduce(dist_y, &(nhg->dist_y[1]), ncomm->nProc_y, MPI_INT, MPI_SUM, ocomm->col_comm); nhg->dist_y[0] = 0; for (i=1; i<=ncomm->nProc_y; ++i) nhg->dist_y[i] += nhg->dist_y[i-1]; #ifdef _DEBUG1 PrintArr(ocomm, "vsn", vsn, ncomm->nProc_x); PrintArr(ocomm, "nsn", nsn, ncomm->nProc_y); #endif /* find mapping of current LOCAL vertex no (in my node) to "new" vertex no LOCAL to dest node*/ for (v = ohg->nVtx-1; v>=0; --v) vno[v] = --vsn[v2Col[v]]; for (n = ohg->nEdge-1; n>=0; --n) nno[n] = --nsn[n2Row[n]]; nsend = MAX(MAX(ohg->nPins, ohg->nVtx), ohg->nEdge); elemsz = MAX(MAX(2, ohg->VtxWeightDim), ohg->EdgeWeightDim); elemsz = (sizeof(float)>sizeof(int)) ? sizeof(float)*elemsz : sizeof(int)*elemsz; proclist = (int *) ZOLTAN_MALLOC(nsend * sizeof(int)); sendbuf = (int *) ZOLTAN_MALLOC(nsend * elemsz); /* first communicate pins */ nPins = 0; for (v = 0; v < ohg->nVtx; ++v) { for (i = ohg->vindex[v]; i < ohg->vindex[v+1]; ++i) { #ifdef _DEBUG1 if ((n2Row[ohg->vedge[i]] * ncomm->nProc_x + v2Col[v])<0 || (n2Row[ohg->vedge[i]] * ncomm->nProc_x + v2Col[v])>=ocomm->nProc) errexit("vertex %d vedge[%d]=%d n2Row=%d #Proc_x=%d v2Col=%d", i, ohg->vedge[i], n2Row[ohg->vedge[i]], ncomm->nProc_x , v2Col[v]); #endif proclist[nPins] = firstproc + n2Row[ohg->vedge[i]] * ncomm->nProc_x + v2Col[v]; sendbuf[2*nPins] = vno[v]; sendbuf[2*nPins+1]= nno[ohg->vedge[i]]; ++nPins; } } #ifdef _DEBUG1 if (nPins!=ohg->nPins) { uprintf(ocomm, "sanity check failed nPins(%d)!=hg->nPins(%d)\n", nPins, ohg->nPins); errexit("terminating"); } #endif --msg_tag; ierr |= Zoltan_Comm_Create(&plan, ohg->nPins, proclist, ocomm->Communicator, msg_tag, &nPins); #ifdef _DEBUG1 if (ncomm->myProc==-1 && nPins>1) { /* this processor is not in new comm but receiving data?*/ uprintf(ocomm, "Something wrong; why I'm receiving data nPins=%d\n", nPins); errexit("terminating"); } #endif if (nPins && (pins = (int *) ZOLTAN_MALLOC(nPins * 2 * sizeof(int)))==NULL) MEMORY_ERROR; --msg_tag; Zoltan_Comm_Do(plan, msg_tag, (char *) sendbuf, 2*sizeof(int), (char *) pins); Zoltan_Comm_Destroy(&plan); /* now communicate vertex map */ nsend = 0; if (!ocomm->myProc_y) { /* only first row sends to the first row of ncomm */ for (v = 0; v < ohg->nVtx; ++v) { proclist[nsend] = firstproc+v2Col[v]; sendbuf[nsend++] = ohg->vmap[v]; } } --msg_tag; ierr |= Zoltan_Comm_Create(&plan, nsend, proclist, ocomm->Communicator, msg_tag, &nVtx); #ifdef _DEBUG1 if (ncomm->myProc==-1 && nVtx>1) { /* this processor is not in new comm but receiving data?*/ uprintf(ocomm, "Something wrong; why I'm receiving data nVtx=%d\n", nVtx); errexit("terminating"); } #endif /* those are only needed in the first row of ncomm */ *vmap = *vdest = NULL; if (!ncomm->myProc_y && nVtx && (!(*vmap = (int *) ZOLTAN_MALLOC(nVtx * sizeof(int))) || !(*vdest = (int *) ZOLTAN_MALLOC(nVtx * sizeof(int))))) MEMORY_ERROR; --msg_tag; Zoltan_Comm_Do(plan, msg_tag, (char *) sendbuf, sizeof(int), (char *) *vmap); if (!ocomm->myProc_y) { /* only first row sends to the first row of ncomm */ for (v = 0; v < ohg->nVtx; ++v) sendbuf[v] = ocomm->myProc; } --msg_tag; Zoltan_Comm_Do(plan, msg_tag, (char *) sendbuf, sizeof(int), (char *) *vdest); if (ncomm->myProc!=-1) { /* I'm in the new comm */ /* ncomm's first row now bcast to other rows */ MPI_Bcast(&nVtx, 1, MPI_INT, 0, ncomm->col_comm); #ifdef _DEBUG1 if (nVtx!=(nhg->dist_x[ncomm->myProc_x+1] - nhg->dist_x[ncomm->myProc_x])) errexit("nVtx(%d)!= nhg->dist_x[ncomm->myProc_x+1] - nhg->dist_x[ncomm->myProc_x](%d)", nVtx, nhg->dist_x[ncomm->myProc_x+1] - nhg->dist_x[ncomm->myProc_x]); #endif if (nVtx && (nhg->vmap = (int *) ZOLTAN_MALLOC(nVtx * sizeof(int)))==NULL) MEMORY_ERROR; for (i=0; i<nVtx; ++i) nhg->vmap[i] = i; } /* now communicate vertex weights */ if (ohg->VtxWeightDim) { if (nVtx) nhg->vwgt = (float*) ZOLTAN_MALLOC(nVtx*ohg->VtxWeightDim*sizeof(float)); --msg_tag; Zoltan_Comm_Do(plan, msg_tag, (char *) ohg->vwgt, ohg->VtxWeightDim*sizeof(float), (char *) nhg->vwgt); if (ncomm->myProc!=-1) /* ncomm's first row now bcast to other rows */ MPI_Bcast(nhg->vwgt, nVtx*ohg->VtxWeightDim, MPI_FLOAT, 0, ncomm->col_comm); } /* communicate fixed vertices, if any */ if (hgp->UseFixedVtx) { if (nVtx) nhg->fixed_part = (int *) ZOLTAN_MALLOC(nVtx*sizeof(int)); --msg_tag; Zoltan_Comm_Do(plan, msg_tag, (char *) ohg->fixed_part, sizeof(int), (char *) nhg->fixed_part); if (ncomm->myProc!=-1) /* ncomm's first row now bcast to other rows */ MPI_Bcast(nhg->fixed_part, nVtx, MPI_INT, 0, ncomm->col_comm); } /* communicate pref parts, if any */ if (hgp->UsePrefPart) { if (nVtx) nhg->pref_part = (int *) ZOLTAN_MALLOC(nVtx*sizeof(int)); --msg_tag; Zoltan_Comm_Do(plan, msg_tag, (char *) ohg->pref_part, sizeof(int), (char *) nhg->pref_part); if (ncomm->myProc!=-1) /* ncomm's first row now bcast to other rows */ MPI_Bcast(nhg->pref_part, nVtx, MPI_INT, 0, ncomm->col_comm); } /* this comm plan is no longer needed. */ Zoltan_Comm_Destroy(&plan); if (ohg->EdgeWeightDim) { /* now communicate edge weights */ nsend = 0; if (!ocomm->myProc_x) /* only first column sends to first column of ncomm */ for (n = 0; n < ohg->nEdge; ++n) proclist[nsend++] = firstproc + n2Row[n]*ncomm->nProc_x; --msg_tag; ierr |= Zoltan_Comm_Create(&plan, nsend, proclist, ocomm->Communicator, msg_tag, &nEdge); #ifdef _DEBUG1 if (ncomm->myProc==-1 && nEdge>1) { /* this processor is not in new comm but receiving data?*/ uprintf(ocomm, "Something wrong; why I'm receiving data nEdge=%d\n", nEdge); errexit("terminating"); } #endif if (ncomm->myProc!=-1) { /* if we're in the new comm */ /* ncomm's first column now bcast to other columns */ MPI_Bcast(&nEdge, 1, MPI_INT, 0, ncomm->row_comm); #ifdef _DEBUG1 if (nEdge != (nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y])) errexit("nEdge(%d)!=nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y](%d)", nEdge, nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y]); #endif } if (nEdge) nhg->ewgt = (float*) ZOLTAN_MALLOC(nEdge*ohg->EdgeWeightDim*sizeof(float)); --msg_tag; Zoltan_Comm_Do(plan, msg_tag, (char *) ohg->ewgt, ohg->EdgeWeightDim*sizeof(float), (char *) nhg->ewgt); if (ncomm->myProc!=-1) { /* if we're in the new comm */ /* ncomm's first column now bcast to other columns */ if (nEdge) MPI_Bcast(nhg->ewgt, nEdge*ohg->EdgeWeightDim, MPI_FLOAT, 0, ncomm->row_comm); } Zoltan_Comm_Destroy(&plan); } else nEdge = (ncomm->myProc==-1) ? 0 : nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y]; if (ncomm->myProc==-1) { #ifdef _DEBUG1 if (nPins || nVtx || nEdge) errexit("I should not have any data: hey nPins=%d nVtx=%d nEdge=%d\n", nPins, nVtx, nEdge); #endif nhg->nEdge = nhg->nVtx = nhg->nPins = 0; } else { nhg->nEdge = nhg->dist_y[ncomm->myProc_y+1] - nhg->dist_y[ncomm->myProc_y]; nhg->nVtx = nhg->dist_x[ncomm->myProc_x+1] - nhg->dist_x[ncomm->myProc_x]; nhg->nPins = nPins; /* Unpack the pins received. */ cnt = (int *) ZOLTAN_CALLOC(nhg->nVtx + 1, sizeof(int)); nhg->vindex = (int *) ZOLTAN_CALLOC(nhg->nVtx + 1, sizeof(int)); nhg->vedge = (int *) ZOLTAN_MALLOC(nhg->nPins * sizeof(int)); if (!cnt || !nhg->vindex || (nPins && !nhg->vedge)) MEMORY_ERROR; /* Count the number of pins per vertex */ for (i = 0; i < nPins; ++i) ++cnt[pins[2*i]]; /* Compute prefix sum to represent hindex correctly. */ for (i = 0; i < nhg->nVtx; ++i) { nhg->vindex[i+1] = nhg->vindex[i] + cnt[i]; cnt[i] = nhg->vindex[i]; } for (i = 0; i < nPins; ++i) nhg->vedge[cnt[pins[2*i]]++] = pins[2*i+1]; nhg->info = ohg->info; nhg->VtxWeightDim = ohg->VtxWeightDim; nhg->EdgeWeightDim = ohg->EdgeWeightDim; ierr = Zoltan_HG_Create_Mirror(zz, nhg); if (ierr != ZOLTAN_OK && ierr != ZOLTAN_WARN) MEMORY_ERROR; } End: Zoltan_Multifree(__FILE__, __LINE__, 10, &proclist, &sendbuf, &pins, &cnt, &vno, &nno, &dist_x, &dist_y, &vsn, &nsn ); return ierr; }
int main(int argc, char **argv) { CResLoader *res_loader; CTcHostIfc *hostifc; int curarg; int fatal_error_count = 0; osfildef *fpout = 0; int next_local = 0; CVmFile *imgfile = 0; CVmFile *objfile = 0; const char *imgfname; int success; char pathbuf[OSFNMAX]; static const char tool_data[4] = { 't', 's', 't', 'L' }; /* initialize for testing */ test_init(); /* create the host interface object */ hostifc = new CTcHostIfcStdio(); /* create a resource loader */ os_get_special_path(pathbuf, sizeof(pathbuf), argv[0], OS_GSP_T3_RES); res_loader = new CResLoader(pathbuf); /* initialize the compiler */ CTcMain::init(hostifc, res_loader, 0); err_try { /* scan arguments */ for (curarg = 1 ; curarg < argc ; ++curarg) { char *p; /* get the argument string for easy reference */ p = argv[curarg]; /* if it's not an option, we're done */ if (*p != '-') break; if (*(p + 1) == 'v') { /* set verbose mode */ G_tcmain->set_verbosity(TRUE); } else { /* * invalid usage - consume all the arguments and fall * through to the usage checker */ curarg = argc; break; } } /* check arguments */ if (curarg + 2 > argc) { /* terminate the compiler */ CTcMain::terminate(); /* delete our objects */ delete res_loader; /* exit with an error */ errexit("usage: test_link [options] obj-file [obj-file [...]] " "image-file\n" "options:\n" " -v - verbose error messages"); } /* set up an output file */ imgfname = argv[argc - 1]; fpout = osfopwb(imgfname, OSFTT3IMG); if (fpout == 0) errexit("unable to open image file"); imgfile = new CVmFile(); imgfile->set_file(fpout, 0); /* read the object files */ for ( ; curarg < argc - 1 ; ++curarg) { osfildef *fpobj; /* open this object file */ fpobj = osfoprb(argv[curarg], OSFTT3OBJ); if (fpobj == 0) { printf("unable to open object file \"%s\"\n", argv[curarg]); goto done; } /* note the loading */ printf("loading %s\n", argv[curarg]); /* set up the CVmFile object for it */ objfile = new CVmFile(); objfile->set_file(fpobj, 0); /* read the object file */ G_cg->load_object_file(objfile, argv[curarg]); /* done with the object file */ delete objfile; objfile = 0; } /* check for unresolved externals */ if (G_prs->check_unresolved_externs()) goto done; /* write the image file */ G_cg->write_to_image(imgfile, 0, tool_data); done: ; } err_catch(exc) { /* * if it's not a general internal or fatal error, log it; don't * log general errors, since these will have been logged as * specific internal errors before being thrown */ if (exc->get_error_code() != TCERR_INTERNAL_ERROR && exc->get_error_code() != TCERR_FATAL_ERROR) G_tok->log_error(TC_SEV_FATAL, exc->get_error_code()); /* count the fatal error */ ++fatal_error_count; } err_end; /* report errors */ fprintf(stderr, "Warnings: %d\n" "Errors: %d\n" "Longest string: %d, longest list: %d\n", G_tcmain->get_warning_count(), G_tcmain->get_error_count() + fatal_error_count, G_cg->get_max_str_len(), G_cg->get_max_list_cnt()); /* * note whether or not the compilation was successful - it succeeded * if we had no errors or fatal errors */ success = (G_tcmain->get_error_count() + fatal_error_count == 0); /* delete the object file object (this closes the file) */ delete imgfile; /* if we have an open object file, close it */ if (objfile != 0) delete objfile; /* * if any errors occurred, delete the object file in the external * file system - this prevents us from leaving around an incomplete * or corrupted image file when compilation fails, and helps * 'make'-type tools realize that they must generate the image file * target again on the next build, even if source files didn't * change */ if (!success) osfdel(imgfname); /* shut down the compiler */ CTcMain::terminate(); /* done with the res loader */ delete res_loader; /* delete the host interface */ delete hostifc; /* show any unfreed memory */ t3_list_memory_blocks(0); /* * terminate - exit with a success indication if we had no errors * (other than warnings); exit with an error indication otherwise */ return (success ? OSEXSUCC : OSEXFAIL); }
void put_recv_buffer(GhostCommunication *gc, int data_parts) { /* put back data */ char *retrieve = r_buffer; std::vector<int>::const_iterator bond_retrieve = r_bondbuffer.begin(); for (int pl = 0; pl < gc->n_part_lists; pl++) { ParticleList *cur_list = gc->part_lists[pl]; if (data_parts == GHOSTTRANS_PARTNUM) { GHOST_TRACE(fprintf(stderr, "%d: reallocating cell %p to size %d, assigned to node %d\n", this_node, cur_list, *(int *)retrieve, gc->node)); prepare_ghost_cell(cur_list, *(int *)retrieve); retrieve += sizeof(int); } else { int np = cur_list->n; Particle *part = cur_list->part; for (int p = 0; p < np; p++) { Particle *pt = &part[p]; if (data_parts & GHOSTTRANS_PROPRTS) { memcpy(&pt->p, retrieve, sizeof(ParticleProperties)); retrieve += sizeof(ParticleProperties); #ifdef GHOSTS_HAVE_BONDS int n_bonds; memcpy(&n_bonds, retrieve, sizeof(int)); retrieve += sizeof(int); if (n_bonds) { realloc_intlist(&pt->bl, pt->bl.n = n_bonds); std::copy(bond_retrieve, bond_retrieve + n_bonds, pt->bl.e); bond_retrieve += n_bonds; } #ifdef EXCLUSIONS memcpy(&n_bonds, retrieve, sizeof(int)); retrieve += sizeof(int); if (n_bonds) { realloc_intlist(&pt->el, pt->el.n = n_bonds); std::copy(bond_retrieve, bond_retrieve + n_bonds, pt->el.e); bond_retrieve += n_bonds; } #endif #endif if (local_particles[pt->p.identity] == NULL) { local_particles[pt->p.identity] = pt; } } if (data_parts & GHOSTTRANS_POSITION) { memcpy(&pt->r, retrieve, sizeof(ParticlePosition)); retrieve += sizeof(ParticlePosition); } if (data_parts & GHOSTTRANS_MOMENTUM) { memcpy(&pt->m, retrieve, sizeof(ParticleMomentum)); retrieve += sizeof(ParticleMomentum); } if (data_parts & GHOSTTRANS_FORCE) { memcpy(&pt->f, retrieve, sizeof(ParticleForce)); retrieve += sizeof(ParticleForce); } #ifdef LB if (data_parts & GHOSTTRANS_COUPLING) { memcpy(&pt->lc, retrieve, sizeof(ParticleLatticeCoupling)); retrieve += sizeof(ParticleLatticeCoupling); } #endif } } } if (data_parts & GHOSTTRANS_PROPRTS) { // skip the final information on bonds to be sent in a second round retrieve += sizeof(int); } if (retrieve - r_buffer != n_r_buffer) { fprintf(stderr, "%d: recv buffer size %d differs " "from what I read out (%ld)\n", this_node, n_r_buffer, retrieve - r_buffer); errexit(); } if (bond_retrieve != r_bondbuffer.end()) { fprintf(stderr, "%d: recv bond buffer was not used up, %ld elements remain\n", this_node, r_bondbuffer.end() - bond_retrieve ); errexit(); } r_bondbuffer.resize(0); }
gk_seq_t *gk_seq_ReadGKMODPSSM(char *filename) { gk_seq_t *seq; gk_idx_t i, j, ii; size_t ntokens, nbytes, len; FILE *fpin; gk_Tokens_t tokens; static char *AAORDER = "ARNDCQEGHILKMFPSTWYVBZX*"; static int PSSMWIDTH = 20; char *header, line[MAXLINELEN]; gk_i2cc2i_t *converter; header = gk_cmalloc(PSSMWIDTH, "gk_seq_ReadGKMODPSSM: header"); converter = gk_i2cc2i_create_common(AAORDER); gk_getfilestats(filename, &len, &ntokens, NULL, &nbytes); len --; seq = gk_malloc(sizeof(gk_seq_t),"gk_seq_ReadGKMODPSSM"); gk_seq_init(seq); seq->len = len; seq->sequence = gk_imalloc(len, "gk_seq_ReadGKMODPSSM"); seq->pssm = gk_iAllocMatrix(len, PSSMWIDTH, 0, "gk_seq_ReadGKMODPSSM"); seq->psfm = gk_iAllocMatrix(len, PSSMWIDTH, 0, "gk_seq_ReadGKMODPSSM"); seq->nsymbols = PSSMWIDTH; seq->name = gk_getbasename(filename); fpin = gk_fopen(filename,"r","gk_seq_ReadGKMODPSSM"); /* Read the header line */ if (fgets(line, MAXLINELEN-1, fpin) == NULL) errexit("Unexpected end of file: %s\n", filename); gk_strtoupper(line); gk_strtokenize(line, " \t\n", &tokens); for (i=0; i<PSSMWIDTH; i++) header[i] = tokens.list[i][0]; gk_freetokenslist(&tokens); /* Read the rest of the lines */ for (i=0, ii=0; ii<len; ii++) { if (fgets(line, MAXLINELEN-1, fpin) == NULL) errexit("Unexpected end of file: %s\n", filename); gk_strtoupper(line); gk_strtokenize(line, " \t\n", &tokens); seq->sequence[i] = converter->c2i[(int)tokens.list[1][0]]; for (j=0; j<PSSMWIDTH; j++) { seq->pssm[i][converter->c2i[(int)header[j]]] = atoi(tokens.list[2+j]); seq->psfm[i][converter->c2i[(int)header[j]]] = atoi(tokens.list[2+PSSMWIDTH+j]); } gk_freetokenslist(&tokens); i++; } seq->len = i; /* Reset the length if certain characters were skipped */ gk_free((void **)&header, LTERM); gk_fclose(fpin); return seq; }
const char *get_name_of_bonded_ia(BondedInteraction type) { switch (type) { case BONDED_IA_FENE: return "FENE"; case BONDED_IA_ANGLE_OLD: return "angle"; case BONDED_IA_ANGLE_HARMONIC: return "angle_harmonic"; case BONDED_IA_ANGLE_COSINE: return "angle_cosine"; case BONDED_IA_ANGLE_COSSQUARE: return "angle_cossquare"; case BONDED_IA_ANGLEDIST: return "angledist"; case BONDED_IA_DIHEDRAL: return "dihedral"; case BONDED_IA_ENDANGLEDIST: return "endangledist"; #ifdef ROTATION case BONDED_IA_HARMONIC_DUMBBELL: return "HARMONIC_DUMBBELL"; #endif case BONDED_IA_HARMONIC: return "HARMONIC"; case BONDED_IA_QUARTIC: return "QUARTIC"; case BONDED_IA_BONDED_COULOMB: return "BONDED_COULOMB"; case BONDED_IA_SUBT_LJ: return "SUBT_LJ"; case BONDED_IA_TABULATED: return "tabulated"; case BONDED_IA_UMBRELLA: return "umbrella"; case BONDED_IA_OVERLAPPED: return "overlapped"; case BONDED_IA_RIGID_BOND: return "RIGID_BOND"; case BONDED_IA_VIRTUAL_BOND: return "VIRTUAL_BOND"; case BONDED_IA_OIF_GLOBAL_FORCES: return "OIF_GLOBAL_FORCES"; case BONDED_IA_OIF_LOCAL_FORCES: return "OIF_LOCAL_FORCES"; case BONDED_IA_OIF_OUT_DIRECTION: return "oif_out_direction"; case BONDED_IA_CG_DNA_BASEPAIR: return "CG_DNA_BASEPAIR"; case BONDED_IA_CG_DNA_STACKING: return "CG_DNA_STACKING"; case BONDED_IA_IBM_TRIEL: return "IBM_TRIEL"; case BONDED_IA_IBM_VOLUME_CONSERVATION: return "IBM_VOLUME_CONSERVATION"; case BONDED_IA_IBM_TRIBEND: return "IBM_TRIBEND"; default: fprintf(stderr, "%d: INTERNAL ERROR: name of unknown interaction %d requested\n", this_node, type); errexit(); } /* just to keep the compiler happy */ return ""; }
void check_particle_consistency() { Particle *part; Cell *cell; int n, np, dir, c, p; int cell_part_cnt=0, ghost_part_cnt=0, local_part_cnt=0; int cell_err_cnt=0; /* checks: part_id, part_pos, local_particles id */ for (c = 0; c < local_cells.n; c++) { cell = local_cells.cell[c]; cell_part_cnt += cell->n; part = cell->part; np = cell->n; for(n=0; n<cell->n ; n++) { if(part[n].p.identity < 0 || part[n].p.identity > max_seen_particle) { fprintf(stderr,"%d: check_particle_consistency: ERROR: Cell %d Part %d has corrupted id=%d\n", this_node,c,n,cell->part[n].p.identity); errexit(); } for(dir=0;dir<3;dir++) { if(PERIODIC(dir) && (part[n].r.p[dir] < -ROUND_ERROR_PREC || part[n].r.p[dir] - box_l[dir] > ROUND_ERROR_PREC)) { fprintf(stderr,"%d: check_particle_consistency: ERROR: illegal pos[%d]=%f of part %d id=%d in cell %d\n", this_node,dir,part[n].r.p[dir],n,part[n].p.identity,c); errexit(); } } if(local_particles[part[n].p.identity] != &part[n]) { fprintf(stderr,"%d: check_particle_consistency: ERROR: address mismatch for part id %d: local: %p cell: %p in cell %d\n", this_node,part[n].p.identity,local_particles[part[n].p.identity], &part[n],c); errexit(); } } } for (c = 0; c < ghost_cells.n; c++) { cell = ghost_cells.cell[c]; if(cell->n>0) { ghost_part_cnt += cell->n; fprintf(stderr,"%d: check_particle_consistency: WARNING: ghost_cell %d contains %d particles!\n", this_node,c,cell->n); } } CELL_TRACE(fprintf(stderr,"%d: check_particle_consistency: %d particles in cells, %d particles in ghost_cells.\n", this_node,cell_part_cnt, ghost_part_cnt)); /* checks: local particle id */ for(n=0; n< max_seen_particle+1; n++) { if(local_particles[n] != NULL) { local_part_cnt ++; if(local_particles[n]->p.identity != n) { fprintf(stderr,"%d: check_particle_consistency: ERROR: local_particles part %d has corrupted id %d\n", this_node,n,local_particles[n]->p.identity); errexit(); } } } CELL_TRACE(fprintf(stderr,"%d: check_particle_consistency: %d particles in local_particles.\n", this_node,local_part_cnt)); /* EXIT on severe errors */ if(cell_err_cnt>0) { fprintf(stderr,"%d: check_particle_consistency: %d ERRORS detected in cell structure!\n",this_node,cell_err_cnt); errexit(); } if(local_part_cnt != cell_part_cnt) { fprintf(stderr,"%d: check_particle_consistency: ERROR: %d parts in cells but %d parts in local_particles\n", this_node,cell_part_cnt,local_part_cnt); for (c = 0; c < local_cells.n; c++) { for(p = 0; p < local_cells.cell[c]->n; p++) fprintf(stderr, "%d: got particle %d in cell %d\n", this_node, local_cells.cell[c]->part[p].p.identity, c); } for(p = 0; p < n_total_particles; p++) if (local_particles[p]) fprintf(stderr, "%d: got particle %d in local_particles\n", this_node, p); if(ghost_part_cnt==0) errexit(); } if(ghost_part_cnt>0) { fprintf(stderr,"%d: check_particle_consistency: ERROR: Found %d illegal ghost particles!\n", this_node,ghost_part_cnt); errexit(); } }
static Lisp_Object Linteger_length(Lisp_Object nil, Lisp_Object a) { a = Labsval(nil, a); errexit(); return Lmsd(nil, a); }
void calc_structurefactor(int type, int order, double **_ff) { int i, j, k, n, qi, p, order2; double qr, twoPI_L, C_sum, S_sum, *ff=NULL; order2 = order*order; *_ff = ff = (double*)realloc(ff,2*order2*sizeof(double)); twoPI_L = 2*PI/box_l[0]; if ((type < 0) || (type > n_particle_types)) { fprintf(stderr,"WARNING: Type %i does not exist!",type); fflush(NULL); errexit(); } else if (order < 1) { fprintf(stderr,"WARNING: parameter \"order\" has to be a whole positive number"); fflush(NULL); errexit(); } else { for(qi=0; qi<2*order2; qi++) { ff[qi] = 0.0; } for(i=0; i<=order; i++) { for(j=-order; j<=order; j++) { for(k=-order; k<=order; k++) { n = i*i + j*j + k*k; if ((n<=order2) && (n>=1)) { C_sum = S_sum = 0.0; for(p=0; p<n_part; p++) { if (partCfg[p].p.type == type) { qr = twoPI_L * ( i*partCfg[p].r.p[0] + j*partCfg[p].r.p[1] + k*partCfg[p].r.p[2] ); C_sum+= cos(qr); S_sum+= sin(qr); } } ff[2*n-2]+= C_sum*C_sum + S_sum*S_sum; ff[2*n-1]++; } } } } n = 0; for(p=0; p<n_part; p++) { if (partCfg[p].p.type == type) n++; } for(qi=0; qi<order2; qi++) if (ff[2*qi+1]!=0) ff[2*qi]/= n*ff[2*qi+1]; } }
int calc_radial_density_map (int xbins,int ybins,int thetabins,double xrange,double yrange, double axis[3], double center[3], IntList *beadids, DoubleList *density_map, DoubleList *density_profile) { int i,j,t; int pi,bi; int nbeadtypes; int beadcount; double vectprod[3]; double pvector[3]; double xdist,ydist,rdist,xav,yav,theta; double xbinwidth,ybinwidth,binvolume; double thetabinwidth; double *thetaradii; int *thetacounts; int xindex,yindex,tindex; xbinwidth = xrange/(double)(xbins); ybinwidth = yrange/(double)(ybins); nbeadtypes = beadids->n; /* Update particles */ updatePartCfg(WITHOUT_BONDS); /*Make sure particles are folded */ for (i = 0 ; i < n_part ; i++) { fold_coordinate(partCfg[i].r.p,partCfg[i].l.i,0); fold_coordinate(partCfg[i].r.p,partCfg[i].l.i,1); fold_coordinate(partCfg[i].r.p,partCfg[i].l.i,2); } beadcount = 0; xav = 0.0; yav = 0.0; for ( pi = 0 ; pi < n_part ; pi++ ) { for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { if ( beadids->e[bi] == partCfg[pi].p.type ) { /* Find the vector from the point to the center */ vecsub(center,partCfg[pi].r.p,pvector); /* Work out x and y coordinates with respect to rotation axis */ /* Find the minimum distance of the point from the axis */ vector_product(axis,pvector,vectprod); xdist = sqrt(sqrlen(vectprod)/sqrlen(axis)); /* Find the projection of the vector from the point to the center onto the axis vector */ ydist = scalar(axis,pvector)/sqrt(sqrlen(axis)); /* Work out relevant indices for x and y */ xindex = (int)(floor(xdist/xbinwidth)); yindex = (int)(floor((ydist+yrange*0.5)/ybinwidth)); /* printf("x %d y %d \n",xindex,yindex); printf("p %f %f %f \n",partCfg[pi].r.p[0],partCfg[pi].r.p[1],partCfg[pi].r.p[2]); printf("pvec %f %f %f \n",pvector[0],pvector[1],pvector[2]); printf("axis %f %f %f \n",axis[0],axis[1],axis[2]); printf("dists %f %f \n",xdist,ydist); fflush(stdout); */ /* Check array bounds */ if ( (xindex < xbins && xindex > 0) && (yindex < ybins && yindex > 0) ) { density_map[bi].e[ybins*xindex+yindex] += 1; xav += xdist; yav += ydist; beadcount += 1; } else { // fprintf(stderr,"ERROR: outside array bounds in calc_radial_density_map"); fflush(NULL); errexit(); } } } } /* Now turn counts into densities for the density map */ for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { for ( i = 0 ; i < xbins ; i++ ) { /* All bins are cylinders and therefore constant in yindex */ binvolume = PI*(2*i*xbinwidth + xbinwidth*xbinwidth)*yrange; for ( j = 0 ; j < ybins ; j++ ) { density_map[bi].e[ybins*i+j] /= binvolume; } } } /* if required calculate the theta density profile */ if ( thetabins > 0 ) { /* Convert the center to an output of the density center */ xav = xav/(double)(beadcount); yav = yav/(double)(beadcount); thetabinwidth = 2*PI/(double)(thetabins); thetaradii = (double*)malloc(thetabins*nbeadtypes*sizeof(double)); thetacounts = (int*)malloc(thetabins*nbeadtypes*sizeof(int)); for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { for ( t = 0 ; t < thetabins ; t++ ) { thetaradii[bi*thetabins+t] = 0.0; thetacounts[bi*thetabins+t] = 0.0; } } /* Maybe there is a nicer way to do this but now I will just repeat the loop over all particles */ for ( pi = 0 ; pi < n_part ; pi++ ) { for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { if ( beadids->e[bi] == partCfg[pi].p.type ) { vecsub(center,partCfg[pi].r.p,pvector); vector_product(axis,pvector,vectprod); xdist = sqrt(sqrlen(vectprod)/sqrlen(axis)); ydist = scalar(axis,pvector)/sqrt(sqrlen(axis)); /* Center the coordinates */ xdist = xdist - xav; ydist = ydist - yav; rdist = sqrt(xdist*xdist+ydist*ydist); if ( ydist >= 0 ) { theta = acos(xdist/rdist); } else { theta = 2*PI-acos(xdist/rdist); } tindex = (int)(floor(theta/thetabinwidth)); thetaradii[bi*thetabins+tindex] += xdist + xav; thetacounts[bi*thetabins+tindex] += 1; if ( tindex >= thetabins ) { fprintf(stderr,"ERROR: outside density_profile array bounds in calc_radial_density_map"); fflush(NULL); errexit(); } else { density_profile[bi].e[tindex] += 1; } } } } /* normalize the theta densities*/ for ( bi = 0 ; bi < nbeadtypes ; bi++ ) { for ( t = 0 ; t < thetabins ; t++ ) { rdist = thetaradii[bi*thetabins+t]/(double)(thetacounts[bi*thetabins+t]); density_profile[bi].e[t] /= rdist*rdist; } } free(thetaradii); free(thetacounts); } // printf("done \n"); return ES_OK; }
int main(int argc, char*argv[]) { char *service = "daytime"; char buf[LINELEN + 1]; struct sockaddr_in fsin; unsigned int alen; int tsock; int usock; int nfds; fd_set rfds; tsock = passiveTCP("tcp", QLEN); usock = passiveUDP("udp"); nfds = MAX(tsock, usock) + 1; FD_ZERO(&rfds); while (1) { FD_SET(tsock, &rfds); (usock, &rfds); if (select(nfds, &rfds, (fd_set *) 0, (fd_set *) 0, (struct timeval *) 0) < 0) errexit("select error : %s\n", strerror(errno)); if (FD_ISSET(tsock, &rfds)) { int ssock; pthread_t thread_id; alen = sizeof(fsin); ssock = accept(tsock, (struct sockaddr *) &fsin, &alen); if (ssock < 0) errexit("accept failed: %s\n", strerror(errno)); if (pthread_create(&thread_id, NULL, connection_handler, (void*) &ssock) < 0) { perror("could not create thread"); return 1; } daytime(buf); (void) write(ssock, buf, strlen(buf)); (void) close(ssock); } if (FD_ISSET(usock, &rfds)) { alen = sizeof(fsin); pthread_t thread_id; if (recvfrom(usock, buf, sizeof(buf), 0, (struct sockaddr *) &fsin, &alen) < 0) errexit("recvfrom: %s\n", strerror(errno)); if (pthread_create(&thread_id, NULL, connection_handlerudp, (void*) &usock) < 0) { perror("could not create thread"); return 1; } daytime(buf); (void) sendto(usock, buf, strlen(buf), 0, (struct sockaddr*) &fsin, sizeof(fsin)); } } void *connection_handlerudp(void *socket_desc) { char buf[LINELEN + 1]; unsigned int alen; struct sockaddr_in fsin; int readsize; int sock = *(int*) socket_desc; alen = sizeof(fsin); while ((readsize = recvfrom(sock, buf, sizeof(buf), 0, (struct sockaddr *) &fsin, &alen)) > 0) { sendto(sock, buf, sizeof(buf), 0, (struct sockaddr *) &fsin, sizeof(fsin)); } if (readsize == 0) { puts("Client disconnected"); fflush(stdout); } else if (readsize == -1) { perror("recv failed"); } errexit("recvfrom: %s\n", strerror(errno)); }
void check_particles() { Particle *part; int *is_here; Cell *cell; int n, np, dir, c, p; int cell_part_cnt=0, local_part_cnt=0; int cell_err_cnt=0; double skin2 = (skin != -1) ? skin/2 : 0; CELL_TRACE(fprintf(stderr, "%d: entering check_particles\n", this_node)); /* check the consistency of particle_nodes */ /* to this aim the array is broadcasted temporarily */ if (this_node != 0) particle_node = malloc((max_seen_particle + 1)*sizeof(int)); is_here = malloc((max_seen_particle + 1)*sizeof(int)); memset(is_here, 0, (max_seen_particle + 1)*sizeof(int)); MPI_Bcast(particle_node, max_seen_particle + 1, MPI_INT, 0, MPI_COMM_WORLD); /* checks: part_id, part_pos, local_particles id */ for (c = 0; c < local_cells.n; c++) { cell = local_cells.cell[c]; cell_part_cnt += cell->n; part = cell->part; np = cell->n; for(n=0; n<cell->n ; n++) { if(part[n].p.identity < 0 || part[n].p.identity > max_seen_particle) { fprintf(stderr,"%d: check_particles: ERROR: Cell %d Part %d has corrupted id=%d\n", this_node,c,n,cell->part[n].p.identity); errexit(); } is_here[part[n].p.identity] = 1; for(dir=0;dir<3;dir++) { if(PERIODIC(dir) && (part[n].r.p[dir] < -skin2 || part[n].r.p[dir] > box_l[dir] + skin2)) { fprintf(stderr,"%d: check_particles: ERROR: illegal pos[%d]=%f of part %d id=%d in cell %d\n", this_node,dir,part[n].r.p[dir],n,part[n].p.identity,c); errexit(); } } if(local_particles[part[n].p.identity] != &part[n]) { fprintf(stderr,"%d: check_particles: ERROR: address mismatch for part id %d: local: %p cell: %p in cell %d\n", this_node,part[n].p.identity,local_particles[part[n].p.identity], &part[n],c); errexit(); } if (particle_node[part[n].p.identity] != this_node) { fprintf(stderr,"%d: check_particles: ERROR: node for particle %d wrong\n", this_node,part[n].p.identity); errexit(); } } } CELL_TRACE(fprintf(stderr,"%d: check_particles: %d particles in local cells.\n", this_node,cell_part_cnt)); /* checks: local particle id */ for(n = 0; n <= max_seen_particle; n++) { if(local_particles[n] != NULL) { local_part_cnt ++; if(local_particles[n]->p.identity != n) { fprintf(stderr,"%d: check_particles: ERROR: local_particles part %d has corrupted id %d\n", this_node,n,local_particles[n]->p.identity); errexit(); } } } CELL_TRACE(fprintf(stderr,"%d: check_particles: %d particles in local_particles.\n", this_node,local_part_cnt)); /* EXIT on severe errors */ if(cell_err_cnt>0) { fprintf(stderr,"%d: check_particles: %d ERRORS detected in cell structure!\n",this_node,cell_err_cnt); errexit(); } /* check whether the particles on my node are actually here */ for (p = 0; p <= max_seen_particle; p++) { if (particle_node[p] == this_node) { if (!is_here[p]) { fprintf(stderr,"%d: check_particles: ERROR: particle %d on this node, but not in local cell\n", this_node, p); } } } free(is_here); if (this_node != 0) { free(particle_node); particle_node = NULL; } else { /* check whether the total count of particles is ok */ c = 0; for (p = 0; p <= max_seen_particle; p++) if (particle_node[p] != -1) c++; if (c != n_total_particles) { fprintf(stderr,"%d: check_particles: #particles in particle_node inconsistent\n", this_node); errexit(); } CELL_TRACE(fprintf(stderr,"%d: check_particles: %d particles in particle_node.\n", this_node,c)); } CELL_TRACE(fprintf(stderr, "%d: leaving check_particles\n", this_node)); }
int dfft_init(double **data, int *local_mesh_dim, int *local_mesh_margin, int* global_mesh_dim, double *global_mesh_off, int *ks_pnum) { int i,j; /* helpers */ int mult[3]; int n_grid[4][3]; /* The four node grids. */ int my_pos[4][3]; /* The position of this_node in the node grids. */ int *n_id[4]; /* linear node identity lists for the node grids. */ int *n_pos[4]; /* positions of nodes in the node grids. */ /* FFTW WISDOM stuff. */ char wisdom_file_name[255]; FILE *wisdom_file; int wisdom_status; FFT_TRACE(fprintf(stderr,"%d: dipolar dfft_init():\n",this_node)); dfft.max_comm_size=0; dfft.max_mesh_size=0; for(i=0;i<4;i++) { n_id[i] = (int *) malloc(1*n_nodes*sizeof(int)); n_pos[i] = (int *) malloc(3*n_nodes*sizeof(int)); } /* === node grids === */ /* real space node grid (n_grid[0]) */ for(i=0;i<3;i++) { n_grid[0][i] = node_grid[i]; my_pos[0][i] = node_pos[i]; } for(i=0;i<n_nodes;i++) { map_node_array(i,&(n_pos[0][3*i+0])); n_id[0][get_linear_index( n_pos[0][3*i+0],n_pos[0][3*i+1],n_pos[0][3*i+2], n_grid[0])] = i; } /* FFT node grids (n_grid[1 - 3]) */ calc_2d_grid(n_nodes,n_grid[1]); /* resort n_grid[1] dimensions if necessary */ dfft.plan[1].row_dir = map_3don2d_grid(n_grid[0], n_grid[1], mult); dfft.plan[0].n_permute = 0; for(i=1;i<4;i++) dfft.plan[i].n_permute = (dfft.plan[1].row_dir+i)%3; for(i=0;i<3;i++) { n_grid[2][i] = n_grid[1][(i+1)%3]; n_grid[3][i] = n_grid[1][(i+2)%3]; } dfft.plan[2].row_dir = (dfft.plan[1].row_dir-1)%3; dfft.plan[3].row_dir = (dfft.plan[1].row_dir-2)%3; /* === communication groups === */ /* copy local mesh off real space charge assignment grid */ for(i=0;i<3;i++) dfft.plan[0].new_mesh[i] = local_mesh_dim[i]; for(i=1; i<4;i++) { dfft.plan[i].g_size=fft_find_comm_groups(n_grid[i-1], n_grid[i], n_id[i-1], n_id[i], dfft.plan[i].group, n_pos[i], my_pos[i]); if(dfft.plan[i].g_size==-1) { /* try permutation */ j = n_grid[i][(dfft.plan[i].row_dir+1)%3]; n_grid[i][(dfft.plan[i].row_dir+1)%3] = n_grid[i][(dfft.plan[i].row_dir+2)%3]; n_grid[i][(dfft.plan[i].row_dir+2)%3] = j; dfft.plan[i].g_size=fft_find_comm_groups(n_grid[i-1], n_grid[i], n_id[i-1], n_id[i], dfft.plan[i].group, n_pos[i], my_pos[i]); if(dfft.plan[i].g_size==-1) { fprintf(stderr,"%d: dipolar INTERNAL ERROR: fft_find_comm_groups error\n", this_node); errexit(); } } dfft.plan[i].send_block = (int *)realloc(dfft.plan[i].send_block, 6*dfft.plan[i].g_size*sizeof(int)); dfft.plan[i].send_size = (int *)realloc(dfft.plan[i].send_size, 1*dfft.plan[i].g_size*sizeof(int)); dfft.plan[i].recv_block = (int *)realloc(dfft.plan[i].recv_block, 6*dfft.plan[i].g_size*sizeof(int)); dfft.plan[i].recv_size = (int *)realloc(dfft.plan[i].recv_size, 1*dfft.plan[i].g_size*sizeof(int)); dfft.plan[i].new_size = fft_calc_local_mesh(my_pos[i], n_grid[i], global_mesh_dim, global_mesh_off, dfft.plan[i].new_mesh, dfft.plan[i].start); permute_ifield(dfft.plan[i].new_mesh,3,-(dfft.plan[i].n_permute)); permute_ifield(dfft.plan[i].start,3,-(dfft.plan[i].n_permute)); dfft.plan[i].n_ffts = dfft.plan[i].new_mesh[0]*dfft.plan[i].new_mesh[1]; /* === send/recv block specifications === */ for(j=0; j<dfft.plan[i].g_size; j++) { int k, node; /* send block: this_node to comm-group-node i (identity: node) */ node = dfft.plan[i].group[j]; dfft.plan[i].send_size[j] = fft_calc_send_block(my_pos[i-1], n_grid[i-1], &(n_pos[i][3*node]), n_grid[i], global_mesh_dim, global_mesh_off, &(dfft.plan[i].send_block[6*j])); permute_ifield(&(dfft.plan[i].send_block[6*j]),3,-(dfft.plan[i-1].n_permute)); permute_ifield(&(dfft.plan[i].send_block[6*j+3]),3,-(dfft.plan[i-1].n_permute)); if(dfft.plan[i].send_size[j] > dfft.max_comm_size) dfft.max_comm_size = dfft.plan[i].send_size[j]; /* First plan send blocks have to be adjusted, since the CA grid may have an additional margin outside the actual domain of the node */ if(i==1) { for(k=0;k<3;k++) dfft.plan[1].send_block[6*j+k ] += local_mesh_margin[2*k]; } /* recv block: this_node from comm-group-node i (identity: node) */ dfft.plan[i].recv_size[j] = fft_calc_send_block(my_pos[i], n_grid[i], &(n_pos[i-1][3*node]), n_grid[i-1], global_mesh_dim, global_mesh_off,&(dfft.plan[i].recv_block[6*j])); permute_ifield(&(dfft.plan[i].recv_block[6*j]),3,-(dfft.plan[i].n_permute)); permute_ifield(&(dfft.plan[i].recv_block[6*j+3]),3,-(dfft.plan[i].n_permute)); if(dfft.plan[i].recv_size[j] > dfft.max_comm_size) dfft.max_comm_size = dfft.plan[i].recv_size[j]; } for(j=0;j<3;j++) dfft.plan[i].old_mesh[j] = dfft.plan[i-1].new_mesh[j]; if(i==1) dfft.plan[i].element = 1; else { dfft.plan[i].element = 2; for(j=0; j<dfft.plan[i].g_size; j++) { dfft.plan[i].send_size[j] *= 2; dfft.plan[i].recv_size[j] *= 2; } } /* DEBUG */ for(j=0;j<n_nodes;j++) { /* MPI_Barrier(comm_cart); */ if(j==this_node) FFT_TRACE(fft_print_fft_plan(dfft.plan[i])); } } /* Factor 2 for complex fields */ dfft.max_comm_size *= 2; dfft.max_mesh_size = (local_mesh_dim[0]*local_mesh_dim[1]*local_mesh_dim[2]); for(i=1;i<4;i++) if(2*dfft.plan[i].new_size > dfft.max_mesh_size) dfft.max_mesh_size = 2*dfft.plan[i].new_size; FFT_TRACE(fprintf(stderr,"%d: dfft.max_comm_size = %d, dfft.max_mesh_size = %d\n", this_node,dfft.max_comm_size,dfft.max_mesh_size)); /* === pack function === */ for(i=1;i<4;i++) { dfft.plan[i].pack_function = fft_pack_block_permute2; FFT_TRACE(fprintf(stderr,"%d: forw plan[%d] permute 2 \n",this_node,i)); } (*ks_pnum)=6; if(dfft.plan[1].row_dir==2) { dfft.plan[1].pack_function = fft_pack_block; FFT_TRACE(fprintf(stderr,"%d: forw plan[%d] permute 0 \n",this_node,1)); (*ks_pnum)=4; } else if(dfft.plan[1].row_dir==1) { dfft.plan[1].pack_function = fft_pack_block_permute1; FFT_TRACE(fprintf(stderr,"%d: forw plan[%d] permute 1 \n",this_node,1)); (*ks_pnum)=5; } /* Factor 2 for complex numbers */ dfft.send_buf = (double *)realloc(dfft.send_buf, dfft.max_comm_size*sizeof(double)); dfft.recv_buf = (double *)realloc(dfft.recv_buf, dfft.max_comm_size*sizeof(double)); (*data) = (double *)realloc((*data), dfft.max_mesh_size*sizeof(double)); dfft.data_buf = (double *)realloc(dfft.data_buf, dfft.max_mesh_size*sizeof(double)); if(!(*data) || !dfft.data_buf || !dfft.recv_buf || !dfft.send_buf) { fprintf(stderr,"%d: Could not allocate FFT data arays\n",this_node); errexit(); } fftw_complex *c_data = (fftw_complex *) (*data); /* === FFT Routines (Using FFTW / RFFTW package)=== */ for(i=1;i<4;i++) { dfft.plan[i].dir = FFTW_FORWARD; /* FFT plan creation. Attention: destroys contents of c_data/data and c_data_buf/data_buf. */ wisdom_status = FFTW_FAILURE; sprintf(wisdom_file_name,"dfftw3_1d_wisdom_forw_n%d.file", dfft.plan[i].new_mesh[2]); if( (wisdom_file=fopen(wisdom_file_name,"r"))!=NULL ) { wisdom_status = fftw_import_wisdom_from_file(wisdom_file); fclose(wisdom_file); } if(dfft.init_tag==1) fftw_destroy_plan(dfft.plan[i].our_fftw_plan); //printf("dfft.plan[%d].n_ffts=%d\n",i,dfft.plan[i].n_ffts); dfft.plan[i].our_fftw_plan = fftw_plan_many_dft(1,&dfft.plan[i].new_mesh[2],dfft.plan[i].n_ffts, c_data,NULL,1,dfft.plan[i].new_mesh[2], c_data,NULL,1,dfft.plan[i].new_mesh[2], dfft.plan[i].dir,FFTW_PATIENT); if( wisdom_status == FFTW_FAILURE && (wisdom_file=fopen(wisdom_file_name,"w"))!=NULL ) { fftw_export_wisdom_to_file(wisdom_file); fclose(wisdom_file); } dfft.plan[i].fft_function = fftw_execute; } /* === The BACK Direction === */ /* this is needed because slightly different functions are used */ for(i=1;i<4;i++) { dfft.back[i].dir = FFTW_BACKWARD; wisdom_status = FFTW_FAILURE; sprintf(wisdom_file_name,"dfftw3_1d_wisdom_back_n%d.file", dfft.plan[i].new_mesh[2]); if( (wisdom_file=fopen(wisdom_file_name,"r"))!=NULL ) { wisdom_status = fftw_import_wisdom_from_file(wisdom_file); fclose(wisdom_file); } if(dfft.init_tag==1) fftw_destroy_plan(dfft.back[i].our_fftw_plan); dfft.back[i].our_fftw_plan = fftw_plan_many_dft(1,&dfft.plan[i].new_mesh[2],dfft.plan[i].n_ffts, c_data,NULL,1,dfft.plan[i].new_mesh[2], c_data,NULL,1,dfft.plan[i].new_mesh[2], dfft.back[i].dir,FFTW_PATIENT); if( wisdom_status == FFTW_FAILURE && (wisdom_file=fopen(wisdom_file_name,"w"))!=NULL ) { fftw_export_wisdom_to_file(wisdom_file); fclose(wisdom_file); } dfft.back[i].fft_function = fftw_execute; dfft.back[i].pack_function = fft_pack_block_permute1; FFT_TRACE(fprintf(stderr,"%d: back plan[%d] permute 1 \n",this_node,i)); } if(dfft.plan[1].row_dir==2) { dfft.back[1].pack_function = fft_pack_block; FFT_TRACE(fprintf(stderr,"%d: back plan[%d] permute 0 \n",this_node,1)); } else if(dfft.plan[1].row_dir==1) { dfft.back[1].pack_function = fft_pack_block_permute2; FFT_TRACE(fprintf(stderr,"%d: back plan[%d] permute 2 \n",this_node,1)); } dfft.init_tag=1; /* free(data); */ for(i=0;i<4;i++) { free(n_id[i]); free(n_pos[i]); } return dfft.max_mesh_size; }
int main(int argc, char *argv[]) { int nflag; /* if not set, output a trailing newline. */ int veclen; /* number of writev arguments. */ struct iovec *iov, *vp; /* Elements to write, current element. */ char space[] = " "; char newline[] = "\n"; char *progname = argv[0]; if (caph_limit_stdio() < 0 || (cap_enter() < 0 && errno != ENOSYS)) err(1, "capsicum"); /* This utility may NOT do getopt(3) option parsing. */ if (*++argv && !strcmp(*argv, "-n")) { ++argv; --argc; nflag = 1; } else nflag = 0; veclen = (argc >= 2) ? (argc - 2) * 2 + 1 : 0; if ((vp = iov = malloc((veclen + 1) * sizeof(struct iovec))) == NULL) errexit(progname, "malloc"); while (argv[0] != NULL) { size_t len; len = strlen(argv[0]); /* * If the next argument is NULL then this is this * the last argument, therefore we need to check * for a trailing \c. */ if (argv[1] == NULL) { /* is there room for a '\c' and is there one? */ if (len >= 2 && argv[0][len - 2] == '\\' && argv[0][len - 1] == 'c') { /* chop it and set the no-newline flag. */ len -= 2; nflag = 1; } } vp->iov_base = *argv; vp++->iov_len = len; if (*++argv) { vp->iov_base = space; vp++->iov_len = 1; } } if (!nflag) { veclen++; vp->iov_base = newline; vp++->iov_len = 1; } /* assert(veclen == (vp - iov)); */ while (veclen) { int nwrite; nwrite = (veclen > IOV_MAX) ? IOV_MAX : veclen; if (writev(STDOUT_FILENO, iov, nwrite) == -1) errexit(progname, "write"); iov += nwrite; veclen -= nwrite; } return 0; }
double magnetic_dipolar_direct_sum_calculations(int force_flag, int energy_flag) { Cell *cell; Particle *part; int i,c,np; double *x=NULL, *y=NULL, *z=NULL; double *mx=NULL, *my=NULL, *mz=NULL; double *fx=NULL, *fy=NULL, *fz=NULL; #ifdef ROTATION double *tx=NULL, *ty=NULL, *tz=NULL; #endif int dip_particles,dip_particles2; double ppos[3]; int img[3]; double u; if(n_nodes!=1) {fprintf(stderr,"error: magnetic Direct Sum is just for one cpu .... \n"); errexit();} if(!(force_flag) && !(energy_flag) ) {fprintf(stderr," I don't know why you call dawaanr_caclulations with all flags zero \n"); return 0;} x = (double *) malloc(sizeof(double)*n_part); y = (double *) malloc(sizeof(double)*n_part); z = (double *) malloc(sizeof(double)*n_part); mx = (double *) malloc(sizeof(double)*n_part); my = (double *) malloc(sizeof(double)*n_part); mz = (double *) malloc(sizeof(double)*n_part); if(force_flag) { fx = (double *) malloc(sizeof(double)*n_part); fy = (double *) malloc(sizeof(double)*n_part); fz = (double *) malloc(sizeof(double)*n_part); #ifdef ROTATION tx = (double *) malloc(sizeof(double)*n_part); ty = (double *) malloc(sizeof(double)*n_part); tz = (double *) malloc(sizeof(double)*n_part); #endif } dip_particles=0; for (c = 0; c < local_cells.n; c++) { cell = local_cells.cell[c]; part = cell->part; np = cell->n; for(i=0;i<np;i++) { if( part[i].p.dipm > 1.e-11 ) { mx[dip_particles]=part[i].r.dip[0]; my[dip_particles]=part[i].r.dip[1]; mz[dip_particles]=part[i].r.dip[2]; /* here we wish the coordinates to be folded into the primary box */ ppos[0]=part[i].r.p[0]; ppos[1]=part[i].r.p[1]; ppos[2]=part[i].r.p[2]; img[0]=part[i].l.i[0]; img[1]=part[i].l.i[1]; img[2]=part[i].l.i[2]; fold_position(ppos, img); x[dip_particles]=ppos[0]; y[dip_particles]=ppos[1]; z[dip_particles]=ppos[2]; if(force_flag) { fx[dip_particles]=0; fy[dip_particles]=0; fz[dip_particles]=0; #ifdef ROTATION tx[dip_particles]=0; ty[dip_particles]=0; tz[dip_particles]=0; #endif } dip_particles++; } } } /*now we do the calculations */ { /* beginning of the area of calculation */ int nx,ny,nz,i,j; double r,rnx,rny,rnz,pe1,pe2,pe3,r3,r5,r2,r7; double a,b,c,d; #ifdef ROTATION double ax,ay,az,bx,by,bz; #endif double rx,ry,rz; double rnx2,rny2; int NCUT[3],NCUT2; for(i=0;i<3;i++){ NCUT[i]=Ncut_off_magnetic_dipolar_direct_sum; if(PERIODIC(i) == 0) {NCUT[i]=0;} } NCUT2=Ncut_off_magnetic_dipolar_direct_sum*Ncut_off_magnetic_dipolar_direct_sum; u=0; fprintf(stderr,"Magnetic Direct sum takes long time. Done of %d: \n",dip_particles); for(i=0;i<dip_particles;i++){ fprintf(stderr,"%d\r",i); for(j=0;j<dip_particles;j++){ pe1=mx[i]*mx[j]+my[i]*my[j]+mz[i]*mz[j]; rx=x[i]-x[j]; ry=y[i]-y[j]; rz=z[i]-z[j]; for(nx=-NCUT[0];nx<=NCUT[0];nx++){ rnx=rx+nx*box_l[0]; rnx2=rnx*rnx; for(ny=-NCUT[1];ny<=NCUT[1];ny++){ rny=ry+ny*box_l[1]; rny2=rny*rny; for(nz=-NCUT[2];nz<=NCUT[2];nz++){ if( !(i==j && nx==0 && ny==0 && nz==0) ) { if(nx*nx+ny*ny +nz*nz<= NCUT2){ rnz=rz+nz*box_l[2]; r2=rnx2+rny2+rnz*rnz; r=sqrt(r2); r3=r2*r; r5=r3*r2; r7=r5*r2; pe2=mx[i]*rnx+my[i]*rny+mz[i]*rnz; pe3=mx[j]*rnx+my[j]*rny+mz[j]*rnz; /*fprintf(stderr,"--------------------------------\n"); fprintf(stderr,"ij: %d %d\n",i,j); fprintf(stderr,"xyz[i]: %lf %lf %lf\n",x[i],y[i],z[i]); fprintf(stderr,"xyz[j]: %lf %lf %lf\n",x[j],y[j],z[j]); fprintf(stderr,"mu xyz[i]: %lf %lf %lf\n",mx[i],my[i],mz[i]); fprintf(stderr,"mu xyz[j]: %lf %lf %lf\n",mx[j],my[j],mz[j]); fprintf(stderr,"rnxyz: %lf %lf %lf\n",rnx,rny,rnz); fprintf(stderr,"--------------------------------\n");*/ //Energy ............................ u+= pe1/r3 - 3.0*pe2*pe3/r5; if(force_flag) { //force ............................ a=mx[i]*mx[j]+my[i]*my[j]+mz[i]*mz[j]; a=3.0*a/r5; b=-15.0*pe2*pe3/r7; c=3.0*pe3/r5; d=3.0*pe2/r5; fx[i]+=(a+b)*rnx+c*mx[i]+d*mx[j]; fy[i]+=(a+b)*rny+c*my[i]+d*my[j]; fz[i]+=(a+b)*rnz+c*mz[i]+d*mz[j]; #ifdef ROTATION //torque ............................ c=3.0/r5*pe3; ax=my[i]*mz[j]-my[j]*mz[i]; ay=mx[j]*mz[i]-mx[i]*mz[j]; az=mx[i]*my[j]-mx[j]*my[i]; bx=my[i]*rnz-rny*mz[i]; by=rnx*mz[i]-mx[i]*rnz; bz=mx[i]*rny-rnx*my[i]; tx[i]+=-ax/r3+bx*c; ty[i]+=-ay/r3+by*c; tz[i]+=-az/r3+bz*c; #endif } /* of force_flag */ } }/* of nx*nx+ny*ny +nz*nz< NCUT*NCUT and !(i==j && nx==0 && ny==0 && nz==0) */ }/* of for nz */ }/* of for ny */ }/* of for nx */ }} /* of j and i */ fprintf(stderr,"done \n"); }/* end of the area of calculation */ /* set the forces, and torques of the particles within Espresso */ if(force_flag) { dip_particles2=0; for (c = 0; c < local_cells.n; c++) { cell = local_cells.cell[c]; part = cell->part; np = cell->n; for(i=0;i<np;i++) { if( part[i].p.dipm > 1.e-11 ) { part[i].f.f[0]+=coulomb.Dprefactor*fx[dip_particles2]; part[i].f.f[1]+=coulomb.Dprefactor*fy[dip_particles2]; part[i].f.f[2]+=coulomb.Dprefactor*fz[dip_particles2]; #ifdef ROTATION part[i].f.torque[0]+=coulomb.Dprefactor*tx[dip_particles2]; part[i].f.torque[1]+=coulomb.Dprefactor*ty[dip_particles2]; part[i].f.torque[2]+=coulomb.Dprefactor*tz[dip_particles2]; #endif dip_particles2++; } } } /* small checking */ if(dip_particles != dip_particles2) { fprintf(stderr,"magnetic direct sum calculations: error mismatch of particles \n"); errexit();} } /*of if force_flag */ /* free memory used */ free(x); free(y); free(z); free(mx); free(my); free(mz); if(force_flag) { free(fx); free(fy); free(fz); #ifdef ROTATION free(tx); free(ty); free(tz); #endif } return 0.5*u; }
void prepare_send_buffer(GhostCommunication *gc, int data_parts) { GHOST_TRACE(fprintf(stderr, "%d: prepare sending to/bcast from %d\n", this_node, gc->node)); /* reallocate send buffer */ n_s_buffer = calc_transmit_size(gc, data_parts); if (n_s_buffer > max_s_buffer) { max_s_buffer = n_s_buffer; s_buffer = (char*)realloc(s_buffer, max_s_buffer); } GHOST_TRACE(fprintf(stderr, "%d: will send %d\n", this_node, n_s_buffer)); s_bondbuffer.resize(0); /* put in data */ char *insert = s_buffer; for (int pl = 0; pl < gc->n_part_lists; pl++) { int np = gc->part_lists[pl]->n; if (data_parts == GHOSTTRANS_PARTNUM) { *(int *)insert = np; insert += sizeof(int); GHOST_TRACE(fprintf(stderr, "%d: %d particles assigned\n", this_node, np)); } else { Particle *part = gc->part_lists[pl]->part; for (int p = 0; p < np; p++) { Particle *pt = &part[p]; if (data_parts & GHOSTTRANS_PROPRTS) { memcpy(insert, &pt->p, sizeof(ParticleProperties)); insert += sizeof(ParticleProperties); #ifdef GHOSTS_HAVE_BONDS *(int *)insert = pt->bl.n; insert += sizeof(int); if (pt->bl.n) { s_bondbuffer.insert(s_bondbuffer.end(), pt->bl.e, pt->bl.e + pt->bl.n); } #ifdef EXCLUSIONS *(int *)insert = pt->el.n; insert += sizeof(int); if (pt->el.n) { s_bondbuffer.insert(s_bondbuffer.end(), pt->el.e, pt->el.e + pt->el.n); } #endif #endif } if (data_parts & GHOSTTRANS_POSSHFTD) { /* ok, this is not nice, but perhaps fast */ ParticlePosition *pp = (ParticlePosition *)insert; int i; memcpy(pp, &pt->r, sizeof(ParticlePosition)); //fprintf(stderr,"%d prep_send_buf: ghost %d shift %f,%f,%f\n",this_node,pt->p.identity,gc->shift[0],gc->shift[1],gc->shift[2]); for (i = 0; i < 3; i++) pp->p[i] += gc->shift[i]; insert += sizeof(ParticlePosition); } else if (data_parts & GHOSTTRANS_POSITION) { memcpy(insert, &pt->r, sizeof(ParticlePosition)); insert += sizeof(ParticlePosition); } if (data_parts & GHOSTTRANS_MOMENTUM) { memcpy(insert, &pt->m, sizeof(ParticleMomentum)); insert += sizeof(ParticleMomentum); } if (data_parts & GHOSTTRANS_FORCE) { memcpy(insert, &pt->f, sizeof(ParticleForce)); insert += sizeof(ParticleForce); } #ifdef LB if (data_parts & GHOSTTRANS_COUPLING) { memcpy(insert, &pt->lc, sizeof(ParticleLatticeCoupling)); insert += sizeof(ParticleLatticeCoupling); } #endif } } } if (data_parts & GHOSTTRANS_PROPRTS) { GHOST_TRACE(fprintf(stderr, "%d: bond buffer size is %ld\n", this_node, s_bondbuffer.size())); *(int *)insert = int(s_bondbuffer.size()); insert += sizeof(int); } if (insert - s_buffer != n_s_buffer) { fprintf(stderr, "%d: INTERNAL ERROR: send buffer size %d " "differs from what I put in (%ld)\n", this_node, n_s_buffer, insert - s_buffer); errexit(); } }
int main(void) { int sfd1, sfd2, cfd1, cfd2, epfd, nfds; struct epoll_event ctlevt, events[MAX_EVENT_NUM], *p_evts; struct sockaddr_un sun; socklen_t sunlen; char str[STR_LENGTH]; int ii; unlink(SOCKET_PATH_CL1); unlink(SOCKET_PATH_CL2); UNIX_SOCK_BIND(sfd1, SOCKET_PATH_CL1); UNIX_SOCK_BIND(sfd2, SOCKET_PATH_CL2); setSignalHandler(); /* if SIGINT then unlink(SOCKET_PATH) */ if( listen( sfd1, LISTEN_BACKLOG) < 0) { errexit(__func__, __LINE__); } if( listen( sfd2, LISTEN_BACKLOG) < 0) { errexit(__func__, __LINE__); } epfd = epoll_create1(0); if(epfd < 0) { errexit(__func__, __LINE__); } MY_EPOLL_CTL(sfd1, EPOLL_CTL_ADD, EPOLLIN); MY_EPOLL_CTL(sfd2, EPOLL_CTL_ADD, EPOLLIN); printf("epoll_wait() then waiting...\n"); while('u') { nfds = epoll_wait( epfd, events, MAX_EVENT_NUM, -1); /* timeout: unlimited*/ printf( "\n%d event occured !\n", nfds); for(ii = 0; ii < nfds; ii++) { p_evts = &events[ii]; if(p_evts->data.fd == sfd1) { printf("sfd1 !\n"); UNIX_SOCK_ACCEPT(sfd1, cfd1); MY_EPOLL_CTL(sfd1, EPOLL_CTL_DEL, EPOLLIN); close(sfd1); sfd1 = 0; MY_EPOLL_CTL(cfd1, EPOLL_CTL_ADD, EPOLLIN); } if(p_evts->data.fd == sfd2) { printf("sfd2 !\n"); UNIX_SOCK_ACCEPT(sfd2, cfd2); MY_EPOLL_CTL(sfd2, EPOLL_CTL_DEL, EPOLLIN); close(sfd2); sfd2 = 0; MY_EPOLL_CTL(cfd2, EPOLL_CTL_ADD, EPOLLIN); } if(p_evts->data.fd == cfd1) { if(p_evts->events & EPOLLIN) { printf("cfd1 R !\n"); read( cfd1, str, sizeof(str)); printf("[s] %s\n", str); MY_EPOLL_CTL(cfd1, EPOLL_CTL_MOD, EPOLLOUT); } if(p_evts->events & EPOLLOUT) { printf("cfd1 W !\n"); strncpy( str, "HELLO", sizeof(str) - 1); write( cfd1, str, sizeof(str)); close(cfd1); cfd1 = 0; } } if(p_evts->data.fd == cfd2) { if(p_evts->events & EPOLLIN) { printf("cfd2 R !\n"); read( cfd2, str, sizeof(str)); printf("[s] %s\n", str); MY_EPOLL_CTL(cfd2, EPOLL_CTL_MOD, EPOLLOUT); } if(p_evts->events & EPOLLOUT) { printf("cfd2 W !\n"); strncpy( str, "WORLD", sizeof(str) - 1); write( cfd2, str, sizeof(str)); close(cfd2); cfd2 = 0; } } } } unlink(SOCKET_PATH_CL1); unlink(SOCKET_PATH_CL2); printf("[s] bye\n"); return 0; }
void ghost_communicator(GhostCommunicator *gc) { MPI_Status status; int n, n2; int data_parts = gc->data_parts; GHOST_TRACE(fprintf(stderr, "%d: ghost_comm %p, data_parts %d\n", this_node, gc, data_parts)); for (n = 0; n < gc->num; n++) { GhostCommunication *gcn = &gc->comm[n]; int comm_type = gcn->type & GHOST_JOBMASK; int prefetch = gcn->type & GHOST_PREFETCH; int poststore = gcn->type & GHOST_PSTSTORE; int node = gcn->node; GHOST_TRACE(fprintf(stderr, "%d: ghost_comm round %d, job %x\n", this_node, n, gc->comm[n].type)); GHOST_TRACE(fprintf(stderr, "%d: ghost_comm shift %f %f %f\n",this_node, gc->comm[n].shift[0], gc->comm[n].shift[1], gc->comm[n].shift[2])); if (comm_type == GHOST_LOCL) cell_cell_transfer(gcn, data_parts); else { /* prepare send buffer if necessary */ if (is_send_op(comm_type, node)) { /* ok, we send this step, prepare send buffer if not yet done */ if (!prefetch) prepare_send_buffer(gcn, data_parts); else { GHOST_TRACE(fprintf(stderr, "%d: ghost_comm using prefetched data for operation %d, sending to %d\n", this_node, n, node)); #ifdef ADDITIONAL_CHECKS if (n_s_buffer != calc_transmit_size(gcn, data_parts)) { fprintf(stderr, "%d: ghost_comm transmission size and current size of cells to transmit do not match\n", this_node); errexit(); } #endif } } else { /* we do not send this time, let's look for a prefetch */ if (prefetch) { /* find next action where we send and which has PREFETCH set */ for (n2 = n+1; n2 < gc->num; n2++) { GhostCommunication *gcn2 = &gc->comm[n2]; int comm_type2 = gcn2->type & GHOST_JOBMASK; int prefetch2 = gcn2->type & GHOST_PREFETCH; int node2 = gcn2->node; if (is_send_op(comm_type2, node2) && prefetch2) { GHOST_TRACE(fprintf(stderr, "%d: ghost_comm prefetch operation %d, is send/bcast to/from %d\n", this_node, n2, node2)); prepare_send_buffer(gcn2, data_parts); break; } } } } /* recv buffer for recv and multinode operations to this node */ if (is_recv_op(comm_type, node)) prepare_recv_buffer(gcn, data_parts); /* transfer data */ switch (comm_type) { case GHOST_RECV: { GHOST_TRACE(fprintf(stderr, "%d: ghost_comm receive from %d (%d bytes)\n", this_node, node, n_r_buffer)); MPI_Recv(r_buffer, n_r_buffer, MPI_BYTE, node, REQ_GHOST_SEND, comm_cart, &status); if (data_parts & GHOSTTRANS_PROPRTS) { int n_bonds = *(int *)(r_buffer + n_r_buffer - sizeof(int)); GHOST_TRACE(fprintf(stderr, "%d: ghost_comm receive from %d (%d bonds)\n", this_node, node, n_bonds)); if (n_bonds) { r_bondbuffer.resize(n_bonds); MPI_Recv(&r_bondbuffer[0], n_bonds, MPI_INT, node, REQ_GHOST_SEND, comm_cart, &status); } } break; } case GHOST_SEND: { GHOST_TRACE(fprintf(stderr, "%d: ghost_comm send to %d (%d bytes)\n", this_node, node, n_s_buffer)); MPI_Send(s_buffer, n_s_buffer, MPI_BYTE, node, REQ_GHOST_SEND, comm_cart); int n_bonds = s_bondbuffer.size(); if (!(data_parts & GHOSTTRANS_PROPRTS) && n_bonds > 0) { fprintf(stderr, "%d: INTERNAL ERROR: not sending properties, but bond buffer not empty\n", this_node); errexit(); } GHOST_TRACE(fprintf(stderr, "%d: ghost_comm send to %d (%d ints)\n", this_node, node, n_bonds)); if (n_bonds) { MPI_Send(&s_bondbuffer[0], n_bonds, MPI_INT, node, REQ_GHOST_SEND, comm_cart); } break; } case GHOST_BCST: GHOST_TRACE(fprintf(stderr, "%d: ghost_comm bcast from %d (%d bytes)\n", this_node, node, (node == this_node) ? n_s_buffer : n_r_buffer)); if (node == this_node) { MPI_Bcast(s_buffer, n_s_buffer, MPI_BYTE, node, comm_cart); int n_bonds = s_bondbuffer.size(); if (!(data_parts & GHOSTTRANS_PROPRTS) && n_bonds > 0) { fprintf(stderr, "%d: INTERNAL ERROR: not sending properties, but bond buffer not empty\n", this_node); errexit(); } if (n_bonds) { MPI_Bcast(&s_bondbuffer[0], n_bonds, MPI_INT, node, comm_cart); } } else { MPI_Bcast(r_buffer, n_r_buffer, MPI_BYTE, node, comm_cart); if (data_parts & GHOSTTRANS_PROPRTS) { int n_bonds = *(int *)(r_buffer + n_r_buffer - sizeof(int)); if (n_bonds) { r_bondbuffer.resize(n_bonds); MPI_Bcast(&r_bondbuffer[0], n_bonds, MPI_INT, node, comm_cart); } } } break; case GHOST_RDCE: GHOST_TRACE(fprintf(stderr, "%d: ghost_comm reduce to %d (%d bytes)\n", this_node, node, n_s_buffer)); if (node == this_node) MPI_Reduce(s_buffer, r_buffer, n_s_buffer, MPI_BYTE, MPI_FORCES_SUM, node, comm_cart); else MPI_Reduce(s_buffer, NULL, n_s_buffer, MPI_BYTE, MPI_FORCES_SUM, node, comm_cart); break; } GHOST_TRACE(MPI_Barrier(comm_cart)); GHOST_TRACE(fprintf(stderr, "%d: ghost_comm done\n", this_node)); /* recv op; write back data directly, if no PSTSTORE delay is requested. */ if (is_recv_op(comm_type, node)) { if (!poststore) { /* forces have to be added, the rest overwritten. Exception is RDCE, where the addition is integrated into the communication. */ if (data_parts == GHOSTTRANS_FORCE && comm_type != GHOST_RDCE) add_forces_from_recv_buffer(gcn); else put_recv_buffer(gcn, data_parts); } else { GHOST_TRACE(fprintf(stderr, "%d: ghost_comm delaying operation %d, recv from %d\n", this_node, n, node)); } } else { /* send op; write back delayed data from last recv, when this was a prefetch send. */ if (poststore) { /* find previous action where we recv and which has PSTSTORE set */ for (n2 = n-1; n2 >= 0; n2--) { GhostCommunication *gcn2 = &gc->comm[n2]; int comm_type2 = gcn2->type & GHOST_JOBMASK; int poststore2 = gcn2->type & GHOST_PSTSTORE; int node2 = gcn2->node; if (is_recv_op(comm_type2, node2) && poststore2) { GHOST_TRACE(fprintf(stderr, "%d: ghost_comm storing delayed recv, operation %d, from %d\n", this_node, n2, node2)); #ifdef ADDITIONAL_CHECKS if (n_r_buffer != calc_transmit_size(gcn2, data_parts)) { fprintf(stderr, "%d: ghost_comm transmission size and current size of cells to transmit do not match\n", this_node); errexit(); } #endif /* as above */ if (data_parts == GHOSTTRANS_FORCE && comm_type != GHOST_RDCE) add_forces_from_recv_buffer(gcn2); else put_recv_buffer(gcn2, data_parts); break; } } } } } } }
/* * Scan each entry in a directory block. */ int dirscan(struct inodesc *idesc) { struct direct *dp; struct bufarea *bp; int dsize, n; long blksiz; #if DIRBLKSIZ > APPLEUFS_DIRBLKSIZ char dbuf[DIRBLKSIZ]; #else char dbuf[APPLEUFS_DIRBLKSIZ]; #endif if (idesc->id_type != DATA) errexit("wrong type to dirscan %d", idesc->id_type); if (idesc->id_entryno == 0 && (idesc->id_filesize & (dirblksiz - 1)) != 0) idesc->id_filesize = roundup(idesc->id_filesize, dirblksiz); blksiz = idesc->id_numfrags * sblock->fs_fsize; if (chkrange(idesc->id_blkno, idesc->id_numfrags)) { idesc->id_filesize -= blksiz; return (SKIP); } /* * If we are are swapping byte order in directory entries, just swap * this block and return. */ if (do_dirswap) { int off; bp = getdirblk(idesc->id_blkno, blksiz); for (off = 0; off < blksiz; off += iswap16(dp->d_reclen)) { dp = (struct direct *)(bp->b_un.b_buf + off); dp->d_ino = bswap32(dp->d_ino); dp->d_reclen = bswap16(dp->d_reclen); if (!newinofmt) { u_int8_t tmp = dp->d_namlen; dp->d_namlen = dp->d_type; dp->d_type = tmp; } if (dp->d_reclen == 0) break; } dirty(bp); idesc->id_filesize -= blksiz; return (idesc->id_filesize > 0 ? KEEPON : STOP); } idesc->id_loc = 0; for (dp = fsck_readdir(idesc); dp != NULL; dp = fsck_readdir(idesc)) { dsize = iswap16(dp->d_reclen); if (dsize > sizeof dbuf) dsize = sizeof dbuf; memmove(dbuf, dp, (size_t)dsize); # if (BYTE_ORDER == LITTLE_ENDIAN) if (!newinofmt && !needswap) { # else if (!newinofmt && needswap) { # endif struct direct *tdp = (struct direct *)dbuf; u_char tmp; tmp = tdp->d_namlen; tdp->d_namlen = tdp->d_type; tdp->d_type = tmp; } idesc->id_dirp = (struct direct *)dbuf; if ((n = (*idesc->id_func)(idesc)) & ALTERED) { # if (BYTE_ORDER == LITTLE_ENDIAN) if (!newinofmt && !doinglevel2 && !needswap) { # else if (!newinofmt && !doinglevel2 && needswap) { # endif struct direct *tdp; u_char tmp; tdp = (struct direct *)dbuf; tmp = tdp->d_namlen; tdp->d_namlen = tdp->d_type; tdp->d_type = tmp; } bp = getdirblk(idesc->id_blkno, blksiz); memmove(bp->b_un.b_buf + idesc->id_loc - dsize, dbuf, (size_t)dsize); dirty(bp); sbdirty(); } if (n & STOP) return (n); } return (idesc->id_filesize > 0 ? KEEPON : STOP); } /* * get next entry in a directory. */ static struct direct * fsck_readdir(struct inodesc *idesc) { struct direct *dp, *ndp; struct bufarea *bp; long size, blksiz, fix, dploc; blksiz = idesc->id_numfrags * sblock->fs_fsize; bp = getdirblk(idesc->id_blkno, blksiz); if (idesc->id_loc % dirblksiz == 0 && idesc->id_filesize > 0 && idesc->id_loc < blksiz) { dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc); if (dircheck(idesc, dp)) goto dpok; if (idesc->id_fix == IGNORE) return (0); fix = dofix(idesc, "DIRECTORY CORRUPTED"); bp = getdirblk(idesc->id_blkno, blksiz); dp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc); dp->d_reclen = iswap16(dirblksiz); dp->d_ino = 0; dp->d_type = 0; dp->d_namlen = 0; dp->d_name[0] = '\0'; if (fix) dirty(bp); else markclean = 0; idesc->id_loc += dirblksiz; idesc->id_filesize -= dirblksiz; return (dp); } dpok: if (idesc->id_filesize <= 0 || idesc->id_loc >= blksiz) return NULL; dploc = idesc->id_loc; dp = (struct direct *)(bp->b_un.b_buf + dploc); idesc->id_loc += iswap16(dp->d_reclen); idesc->id_filesize -= iswap16(dp->d_reclen); if ((idesc->id_loc % dirblksiz) == 0) return (dp); ndp = (struct direct *)(bp->b_un.b_buf + idesc->id_loc); if (idesc->id_loc < blksiz && idesc->id_filesize > 0 && dircheck(idesc, ndp) == 0) { size = dirblksiz - (idesc->id_loc % dirblksiz); idesc->id_loc += size; idesc->id_filesize -= size; if (idesc->id_fix == IGNORE) return (0); fix = dofix(idesc, "DIRECTORY CORRUPTED"); bp = getdirblk(idesc->id_blkno, blksiz); dp = (struct direct *)(bp->b_un.b_buf + dploc); dp->d_reclen = iswap16(iswap16(dp->d_reclen) + size); if (fix) dirty(bp); else markclean = 0; } return (dp); } /* * Verify that a directory entry is valid. * This is a superset of the checks made in the kernel. */ static int dircheck(struct inodesc *idesc, struct direct *dp) { int size; char *cp; u_char namlen, type; int spaceleft; spaceleft = dirblksiz - (idesc->id_loc % dirblksiz); if (iswap32(dp->d_ino) >= maxino || dp->d_reclen == 0 || iswap16(dp->d_reclen) > spaceleft || (iswap16(dp->d_reclen) & 0x3) != 0) return (0); if (dp->d_ino == 0) return (1); size = DIRSIZ(!newinofmt, dp, needswap); # if (BYTE_ORDER == LITTLE_ENDIAN) if (!newinofmt && !needswap) { # else if (!newinofmt && needswap) { # endif type = dp->d_namlen; namlen = dp->d_type; } else { namlen = dp->d_namlen; type = dp->d_type; } if (iswap16(dp->d_reclen) < size || idesc->id_filesize < size || /* namlen > MAXNAMLEN || */ type > 15) return (0); for (cp = dp->d_name, size = 0; size < namlen; size++) if (*cp == '\0' || (*cp++ == '/')) return (0); if (*cp != '\0') return (0); return (1); } void direrror(ino_t ino, const char *errmesg) { fileerror(ino, ino, errmesg); } void fileerror(ino_t cwd, ino_t ino, const char *errmesg) { union dinode *dp; char pathbuf[MAXPATHLEN + 1]; uint16_t mode; pwarn("%s ", errmesg); pinode(ino); printf("\n"); getpathname(pathbuf, sizeof(pathbuf), cwd, ino); if (ino < ROOTINO || ino > maxino) { pfatal("NAME=%s\n", pathbuf); return; } dp = ginode(ino); if (ftypeok(dp)) { mode = DIP(dp, mode); pfatal("%s=%s\n", (iswap16(mode) & IFMT) == IFDIR ? "DIR" : "FILE", pathbuf); } else pfatal("NAME=%s\n", pathbuf); } void adjust(struct inodesc *idesc, int lcnt) { union dinode *dp; int16_t nlink; int saveresolved; dp = ginode(idesc->id_number); nlink = iswap16(DIP(dp, nlink)); if (nlink == lcnt) { /* * If we have not hit any unresolved problems, are running * in preen mode, and are on a file system using soft updates, * then just toss any partially allocated files. */ if (resolved && preen && usedsoftdep) { clri(idesc, "UNREF", 1); return; } else { /* * The file system can be marked clean even if * a file is not linked up, but is cleared. * Hence, resolved should not be cleared when * linkup is answered no, but clri is answered yes. */ saveresolved = resolved; if (linkup(idesc->id_number, (ino_t)0, NULL) == 0) { resolved = saveresolved; clri(idesc, "UNREF", 0); return; } /* * Account for the new reference created by linkup(). */ dp = ginode(idesc->id_number); lcnt--; } } if (lcnt != 0) { pwarn("LINK COUNT %s", (lfdir == idesc->id_number) ? lfname : ((iswap16(DIP(dp, mode)) & IFMT) == IFDIR ? "DIR" : "FILE")); pinode(idesc->id_number); printf(" COUNT %d SHOULD BE %d", nlink, nlink - lcnt); if (preen || usedsoftdep) { if (lcnt < 0) { printf("\n"); pfatal("LINK COUNT INCREASING"); } if (preen) printf(" (ADJUSTED)\n"); } if (preen || reply("ADJUST") == 1) { DIP_SET(dp, nlink, iswap16(nlink - lcnt)); inodirty(); } else markclean = 0; } } static int mkentry(struct inodesc *idesc) { struct direct *dirp = idesc->id_dirp; struct direct newent; int newlen, oldlen; newent.d_namlen = strlen(idesc->id_name); newlen = DIRSIZ(0, &newent, 0); if (dirp->d_ino != 0) oldlen = DIRSIZ(0, dirp, 0); else oldlen = 0; if (iswap16(dirp->d_reclen) - oldlen < newlen) return (KEEPON); newent.d_reclen = iswap16(iswap16(dirp->d_reclen) - oldlen); dirp->d_reclen = iswap16(oldlen); dirp = (struct direct *)(((char *)dirp) + oldlen); /* ino to be entered is in id_parent */ dirp->d_ino = iswap32(idesc->id_parent); dirp->d_reclen = newent.d_reclen; if (newinofmt) dirp->d_type = inoinfo(idesc->id_parent)->ino_type; else dirp->d_type = 0; dirp->d_namlen = newent.d_namlen; memmove(dirp->d_name, idesc->id_name, (size_t)newent.d_namlen + 1); # if (BYTE_ORDER == LITTLE_ENDIAN) /* * If the entry was split, dirscan() will only reverse the byte * order of the original entry, and not the new one, before * writing it back out. So, we reverse the byte order here if * necessary. */ if (oldlen != 0 && !newinofmt && !doinglevel2 && !needswap) { # else if (oldlen != 0 && !newinofmt && !doinglevel2 && needswap) { # endif u_char tmp; tmp = dirp->d_namlen; dirp->d_namlen = dirp->d_type; dirp->d_type = tmp; } return (ALTERED|STOP); } static int chgino(struct inodesc *idesc) { struct direct *dirp = idesc->id_dirp; if (memcmp(dirp->d_name, idesc->id_name, (int)dirp->d_namlen + 1)) return (KEEPON); dirp->d_ino = iswap32(idesc->id_parent); if (newinofmt) dirp->d_type = inoinfo(idesc->id_parent)->ino_type; else dirp->d_type = 0; return (ALTERED|STOP); } int linkup(ino_t orphan, ino_t parentdir, char *name) { union dinode *dp; int lostdir; ino_t oldlfdir; struct inodesc idesc; char tempname[BUFSIZ]; int16_t nlink; uint16_t mode; memset(&idesc, 0, sizeof(struct inodesc)); dp = ginode(orphan); mode = iswap16(DIP(dp, mode)); nlink = iswap16(DIP(dp, nlink)); lostdir = (mode & IFMT) == IFDIR; pwarn("UNREF %s ", lostdir ? "DIR" : "FILE"); pinode(orphan); if (preen && DIP(dp, size) == 0) return (0); if (preen) printf(" (RECONNECTED)\n"); else if (reply("RECONNECT") == 0) { markclean = 0; return (0); } if (parentdir != 0) inoinfo(parentdir)->ino_linkcnt++; if (lfdir == 0) { dp = ginode(ROOTINO); idesc.id_name = lfname; idesc.id_type = DATA; idesc.id_func = findino; idesc.id_number = ROOTINO; if ((ckinode(dp, &idesc) & FOUND) != 0) { lfdir = idesc.id_parent; } else { pwarn("NO lost+found DIRECTORY"); if (preen || reply("CREATE")) { lfdir = allocdir(ROOTINO, (ino_t)0, lfmode); if (lfdir != 0) { if (makeentry(ROOTINO, lfdir, lfname) != 0) { numdirs++; if (preen) printf(" (CREATED)\n"); } else { freedir(lfdir, ROOTINO); lfdir = 0; if (preen) printf("\n"); } } if (lfdir != 0) { reparent(lfdir, ROOTINO); } } } if (lfdir == 0) { pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); markclean = 0; return (0); } } dp = ginode(lfdir); mode = DIP(dp, mode); mode = iswap16(mode); if ((mode & IFMT) != IFDIR) { pfatal("lost+found IS NOT A DIRECTORY"); if (reply("REALLOCATE") == 0) { markclean = 0; return (0); } oldlfdir = lfdir; lfdir = allocdir(ROOTINO, (ino_t)0, lfmode); if (lfdir == 0) { pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); markclean = 0; return (0); } if ((changeino(ROOTINO, lfname, lfdir) & ALTERED) == 0) { pfatal("SORRY. CANNOT CREATE lost+found DIRECTORY\n\n"); markclean = 0; return (0); } inodirty(); reparent(lfdir, ROOTINO); idesc.id_type = ADDR; idesc.id_func = pass4check; idesc.id_number = oldlfdir; adjust(&idesc, inoinfo(oldlfdir)->ino_linkcnt + 1); inoinfo(oldlfdir)->ino_linkcnt = 0; dp = ginode(lfdir); } if (inoinfo(lfdir)->ino_state != DFOUND) { pfatal("SORRY. NO lost+found DIRECTORY\n\n"); markclean = 0; return (0); } (void)lftempname(tempname, orphan); if (makeentry(lfdir, orphan, (name ? name : tempname)) == 0) { pfatal("SORRY. NO SPACE IN lost+found DIRECTORY"); printf("\n\n"); markclean = 0; return (0); } inoinfo(orphan)->ino_linkcnt--; if (lostdir) { if ((changeino(orphan, "..", lfdir) & ALTERED) == 0 && parentdir != (ino_t)-1) (void)makeentry(orphan, lfdir, ".."); dp = ginode(lfdir); nlink = DIP(dp, nlink); DIP_SET(dp, nlink, iswap16(iswap16(nlink) + 1)); inodirty(); inoinfo(lfdir)->ino_linkcnt++; reparent(orphan, lfdir); pwarn("DIR I=%llu CONNECTED. ", (unsigned long long)orphan); if (parentdir != (ino_t)-1) printf("PARENT WAS I=%llu\n", (unsigned long long)parentdir); if (preen == 0) printf("\n"); } return (1); } /* * fix an entry in a directory. */ int changeino(ino_t dir, const char *name, ino_t newnum) { struct inodesc idesc; memset(&idesc, 0, sizeof(struct inodesc)); idesc.id_type = DATA; idesc.id_func = chgino; idesc.id_number = dir; idesc.id_fix = DONTKNOW; idesc.id_name = name; idesc.id_parent = newnum; /* new value for name */ return (ckinode(ginode(dir), &idesc)); } /* * make an entry in a directory */ int makeentry(ino_t parent, ino_t ino, const char *name) { union dinode *dp; struct inodesc idesc; char pathbuf[MAXPATHLEN + 1]; if (parent < ROOTINO || parent >= maxino || ino < ROOTINO || ino >= maxino) return (0); memset(&idesc, 0, sizeof(struct inodesc)); idesc.id_type = DATA; idesc.id_func = mkentry; idesc.id_number = parent; idesc.id_parent = ino; /* this is the inode to enter */ idesc.id_fix = DONTKNOW; idesc.id_name = name; dp = ginode(parent); if (iswap64(DIP(dp, size)) % dirblksiz) { DIP_SET(dp, size, iswap64(roundup(iswap64(DIP(dp, size)), dirblksiz))); inodirty(); } if ((ckinode(dp, &idesc) & ALTERED) != 0) return (1); getpathname(pathbuf, sizeof(pathbuf), parent, parent); dp = ginode(parent); if (expanddir(dp, pathbuf) == 0) return (0); return (ckinode(dp, &idesc) & ALTERED); } /* * Attempt to expand the size of a directory */ static int expanddir(union dinode *dp, char *name) { daddr_t lastbn, newblk, dirblk; struct bufarea *bp; char *cp; #if DIRBLKSIZ > APPLEUFS_DIRBLKSIZ char firstblk[DIRBLKSIZ]; #else char firstblk[APPLEUFS_DIRBLKSIZ]; #endif struct ufs1_dinode *dp1 = NULL; struct ufs2_dinode *dp2 = NULL; if (is_ufs2) dp2 = &dp->dp2; else dp1 = &dp->dp1; lastbn = lblkno(sblock, iswap64(DIP(dp, size))); if (lastbn >= NDADDR - 1 || DIP(dp, db[lastbn]) == 0 || DIP(dp, size) == 0) return (0); if ((newblk = allocblk(sblock->fs_frag)) == 0) return (0); if (is_ufs2) { dp2->di_db[lastbn + 1] = dp2->di_db[lastbn]; dp2->di_db[lastbn] = iswap64(newblk); dp2->di_size = iswap64(iswap64(dp2->di_size)+sblock->fs_bsize); dp2->di_blocks = iswap64(iswap64(dp2->di_blocks) + btodb(sblock->fs_bsize)); dirblk = iswap64(dp2->di_db[lastbn + 1]); } else { dp1->di_db[lastbn + 1] = dp1->di_db[lastbn]; dp1->di_db[lastbn] = iswap32((int32_t)newblk); dp1->di_size = iswap64(iswap64(dp1->di_size)+sblock->fs_bsize); dp1->di_blocks = iswap32(iswap32(dp1->di_blocks) + btodb(sblock->fs_bsize)); dirblk = iswap32(dp1->di_db[lastbn + 1]); } bp = getdirblk(dirblk, sblksize(sblock, DIP(dp, size), lastbn + 1)); if (bp->b_errs) goto bad; memmove(firstblk, bp->b_un.b_buf, dirblksiz); bp = getdirblk(newblk, sblock->fs_bsize); if (bp->b_errs) goto bad; memmove(bp->b_un.b_buf, firstblk, dirblksiz); emptydir.dot_reclen = iswap16(dirblksiz); for (cp = &bp->b_un.b_buf[dirblksiz]; cp < &bp->b_un.b_buf[sblock->fs_bsize]; cp += dirblksiz) memmove(cp, &emptydir, sizeof emptydir); dirty(bp); bp = getdirblk(dirblk, sblksize(sblock, DIP(dp, size), lastbn + 1)); if (bp->b_errs) goto bad; memmove(bp->b_un.b_buf, &emptydir, sizeof emptydir); pwarn("NO SPACE LEFT IN %s", name); if (preen) printf(" (EXPANDED)\n"); else if (reply("EXPAND") == 0) goto bad; dirty(bp); inodirty(); return (1); bad: if (is_ufs2) { dp2->di_db[lastbn] = dp2->di_db[lastbn + 1]; dp2->di_db[lastbn + 1] = 0; dp2->di_size = iswap64(iswap64(dp2->di_size)-sblock->fs_bsize); dp2->di_blocks = iswap64(iswap64(dp2->di_blocks) - btodb(sblock->fs_bsize)); } else { dp1->di_db[lastbn] = dp1->di_db[lastbn + 1]; dp1->di_db[lastbn + 1] = 0; dp1->di_size = iswap64(iswap64(dp1->di_size)-sblock->fs_bsize); dp1->di_blocks = iswap32(iswap32(dp1->di_blocks) - btodb(sblock->fs_bsize)); } freeblk(newblk, sblock->fs_frag); markclean = 0; return (0); } /* * allocate a new directory */ ino_t allocdir(ino_t parent, ino_t request, int mode) { ino_t ino; char *cp; union dinode *dp; struct bufarea *bp; struct inoinfo *inp; struct dirtemplate *dirp; daddr_t dirblk; ino = allocino(request, IFDIR|mode); if (ino < ROOTINO) return 0; dirhead.dot_reclen = iswap16(12); dirhead.dotdot_reclen = iswap16(dirblksiz - 12); odirhead.dot_reclen = iswap16(12); odirhead.dotdot_reclen = iswap16(dirblksiz - 12); odirhead.dot_namlen = iswap16(1); odirhead.dotdot_namlen = iswap16(2); if (newinofmt) dirp = &dirhead; else dirp = (struct dirtemplate *)&odirhead; dirp->dot_ino = iswap32(ino); dirp->dotdot_ino = iswap32(parent); dp = ginode(ino); dirblk = is_ufs2 ? iswap64(dp->dp2.di_db[0]) : iswap32(dp->dp1.di_db[0]); bp = getdirblk(dirblk, sblock->fs_fsize); if (bp->b_errs) { freeino(ino); return (0); } memmove(bp->b_un.b_buf, dirp, sizeof(struct dirtemplate)); emptydir.dot_reclen = iswap16(dirblksiz); for (cp = &bp->b_un.b_buf[dirblksiz]; cp < &bp->b_un.b_buf[sblock->fs_fsize]; cp += dirblksiz) memmove(cp, &emptydir, sizeof emptydir); dirty(bp); DIP_SET(dp, nlink, iswap16(2)); inodirty(); if (ino == ROOTINO) { inoinfo(ino)->ino_linkcnt = iswap16(DIP(dp, nlink)); cacheino(dp, ino); return(ino); } if (inoinfo(parent)->ino_state != DSTATE && inoinfo(parent)->ino_state != DFOUND) { freeino(ino); return (0); } cacheino(dp, ino); inp = getinoinfo(ino); inp->i_parent = parent; inp->i_dotdot = parent; inoinfo(ino)->ino_state = inoinfo(parent)->ino_state; if (inoinfo(ino)->ino_state == DSTATE) { inoinfo(ino)->ino_linkcnt = iswap16(DIP(dp, nlink)); inoinfo(parent)->ino_linkcnt++; } dp = ginode(parent); DIP_SET(dp, nlink, iswap16(iswap16(DIP(dp, nlink)) + 1)); inodirty(); return (ino); }
int Zoltan_PHG_Redistribute( ZZ *zz, PHGPartParams *hgp, /* Input: parameters; used only for user's request of nProc_x and nProc_y */ HGraph *ohg, /* Input: Local part of distributed hypergraph */ int lo, int hi, /* Input: range of proc ranks (inclusive) to be included in new communicator: ncomm */ PHGComm *ncomm, /* Output: Communicators of new distribution */ HGraph *nhg, /* Output: Newly redistributed hypergraph */ int **vmap, /* Output: allocated with the size nhg->nVtx and vertex map from nhg to ohg's local vertex number*/ int **vdest /* Output: allocated with the size nhg->nVtx and stores dest proc in ocomm */ ) { char * yo = "Zoltan_PHG_Redistribute"; PHGComm *ocomm = ohg->comm; int *v2Col, *n2Row, ierr=ZOLTAN_OK, i, *ranks; int reqx=hgp->nProc_x_req, reqy=hgp->nProc_y_req; float frac; MPI_Group allgrp, newgrp; MPI_Comm nmpicomm; if (ocomm->nProc==1){ errexit("%s: ocomm->nProc==1", yo); return ZOLTAN_FATAL; } /* create a new communicator for procs[lo..hi] */ MPI_Comm_group(ocomm->Communicator, &allgrp); ranks = (int *) ZOLTAN_MALLOC(ocomm->nProc * sizeof(int)); for (i=lo; i<=hi; ++i) ranks[i-lo] = i; MPI_Group_incl(allgrp, hi-lo+1, ranks, &newgrp); MPI_Comm_create(ocomm->Communicator, newgrp, &nmpicomm); MPI_Group_free(&newgrp); MPI_Group_free(&allgrp); ZOLTAN_FREE(&ranks); if (reqx==1 || reqy==1) ; else reqx = reqy = -1; /* fill ncomm */ ierr = Zoltan_PHG_Set_2D_Proc_Distrib(ocomm->zz, nmpicomm, ocomm->myProc-lo, hi-lo+1, reqx, reqy, ncomm); v2Col = (int *) ZOLTAN_MALLOC(ohg->nVtx * sizeof(int)); n2Row = (int *) ZOLTAN_MALLOC(ohg->nEdge * sizeof(int)); /* UVC: TODO very simple straight forward partitioning right now; later we can implement a more "load balanced", or smarter mechanisms */ /* KDDKDD 5/11/07: Round-off error in the computation of v2Col * and n2Row can lead to different answers on different platforms. * Vertices or edges get sent to different processors during the * split, resulting in different matchings and, thus, different * answers. * Problem was observed on hg_cage10, zdrive.inp.phg.ipm.nproc_vertex1 * and zdrive.inp.phg.ipm.nproc_edge1; * solaris machine seamus and linux machine patches give different * results due to differences in n2Row and v2Col, respectively. * Neither answer is wrong, * but the linux results result in FAILED test in test_zoltan. */ frac = (float) ohg->nVtx / (float) ncomm->nProc_x; for (i=0; i<ohg->nVtx; ++i) v2Col[i] = (int) ((float) i / frac); frac = (float) ohg->nEdge / (float) ncomm->nProc_y; for (i=0; i<ohg->nEdge; ++i) n2Row[i] = (int) ((float) i / frac); ierr |= Zoltan_PHG_Redistribute_Hypergraph(zz, hgp, ohg, lo, v2Col, n2Row, ncomm, nhg, vmap, vdest); Zoltan_Multifree(__FILE__, __LINE__, 2, &v2Col, &n2Row); return ierr; }
pass5() { int c, blk, frags, sumsize, mapsize; daddr_t dbase, dmax, d; register long i, j; struct csum *cs; time_t now; struct csum cstotal; struct inodesc idesc; char buf[MAXBSIZE]; register struct cg *newcg = (struct cg *)buf; bzero((char *)newcg, sblock.fs_cgsize); newcg->cg_magic = CG_MAGIC; bzero((char *)&idesc, sizeof(struct inodesc)); idesc.id_type = ADDR; bzero((char *)&cstotal, sizeof(struct csum)); sumsize = cgrp.cg_iused - (char *)(&cgrp); mapsize = &cgrp.cg_free[howmany(sblock.fs_fpg, NBBY)] - (u_char *)cgrp.cg_iused; (void)time(&now); for (c = 0; c < sblock.fs_ncg; c++) { getblk(&cgblk, cgtod(&sblock, c), sblock.fs_cgsize); if (cgrp.cg_magic != CG_MAGIC) pfatal("CG %d: BAD MAGIC NUMBER\n", c); dbase = cgbase(&sblock, c); dmax = dbase + sblock.fs_fpg; if (dmax > sblock.fs_size) dmax = sblock.fs_size; if (now > cgrp.cg_time) newcg->cg_time = cgrp.cg_time; else newcg->cg_time = now; newcg->cg_cgx = c; if (c == sblock.fs_ncg - 1) newcg->cg_ncyl = sblock.fs_ncyl % sblock.fs_cpg; else newcg->cg_ncyl = sblock.fs_cpg; newcg->cg_niblk = sblock.fs_ipg; newcg->cg_ndblk = dmax - dbase; newcg->cg_cs.cs_ndir = 0; newcg->cg_cs.cs_nffree = 0; newcg->cg_cs.cs_nbfree = 0; newcg->cg_cs.cs_nifree = sblock.fs_ipg; if (cgrp.cg_rotor < newcg->cg_ndblk) newcg->cg_rotor = cgrp.cg_rotor; else newcg->cg_rotor = 0; if (cgrp.cg_frotor < newcg->cg_ndblk) newcg->cg_frotor = cgrp.cg_frotor; else newcg->cg_frotor = 0; if (cgrp.cg_irotor < newcg->cg_niblk) newcg->cg_irotor = cgrp.cg_irotor; else newcg->cg_irotor = 0; bzero((char *)newcg->cg_frsum, sizeof newcg->cg_frsum); bzero((char *)newcg->cg_btot, sizeof newcg->cg_btot); bzero((char *)newcg->cg_b, sizeof newcg->cg_b); bzero((char *)newcg->cg_free, howmany(sblock.fs_fpg, NBBY)); bzero((char *)newcg->cg_iused, howmany(sblock.fs_ipg, NBBY)); j = sblock.fs_ipg * c; for (i = 0; i < sblock.fs_ipg; j++, i++) { switch (statemap[j]) { case USTATE: break; case DSTATE: case DCLEAR: case DFOUND: newcg->cg_cs.cs_ndir++; /* fall through */ case FSTATE: case FCLEAR: newcg->cg_cs.cs_nifree--; setbit(newcg->cg_iused, i); break; default: if (j < ROOTINO) break; errexit("BAD STATE %d FOR INODE I=%d", statemap[j], j); } } if (c == 0) for (i = 0; i < ROOTINO; i++) { setbit(newcg->cg_iused, i); newcg->cg_cs.cs_nifree--; } for (i = 0, d = dbase; d <= dmax - sblock.fs_frag; d += sblock.fs_frag, i += sblock.fs_frag) { frags = 0; for (j = 0; j < sblock.fs_frag; j++) { if (getbmap(d + j)) continue; setbit(newcg->cg_free, i + j); frags++; } if (frags == sblock.fs_frag) { newcg->cg_cs.cs_nbfree++; j = cbtocylno(&sblock, i); newcg->cg_btot[j]++; newcg->cg_b[j][cbtorpos(&sblock, i)]++; } else if (frags > 0) { newcg->cg_cs.cs_nffree += frags; blk = blkmap(&sblock, newcg->cg_free, i); fragacct(&sblock, blk, newcg->cg_frsum, 1); } } for (frags = d; d < dmax; d++) { if (getbmap(d)) continue; setbit(newcg->cg_free, d - dbase); newcg->cg_cs.cs_nffree++; } if (frags != d) { blk = blkmap(&sblock, newcg->cg_free, (frags - dbase)); fragacct(&sblock, blk, newcg->cg_frsum, 1); } cstotal.cs_nffree += newcg->cg_cs.cs_nffree; cstotal.cs_nbfree += newcg->cg_cs.cs_nbfree; cstotal.cs_nifree += newcg->cg_cs.cs_nifree; cstotal.cs_ndir += newcg->cg_cs.cs_ndir; if (bcmp(newcg->cg_iused, cgrp.cg_iused, mapsize) != 0 && dofix(&idesc, "BLK(S) MISSING IN BIT MAPS")) { bcopy(newcg->cg_iused, cgrp.cg_iused, mapsize); cgdirty(); } if (bcmp((char *)newcg, (char *)&cgrp, sumsize) != 0 && dofix(&idesc, "SUMMARY INFORMATION BAD")) { bcopy((char *)newcg, (char *)&cgrp, sumsize); cgdirty(); } cs = &sblock.fs_cs(&sblock, c); if (bcmp((char *)&newcg->cg_cs, (char *)cs, sizeof *cs) != 0 && dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { bcopy((char *)&newcg->cg_cs, (char *)cs, sizeof *cs); sbdirty(); } } if (bcmp((char *)&cstotal, (char *)&sblock.fs_cstotal, sizeof *cs) != 0 && dofix(&idesc, "FREE BLK COUNT(S) WRONG IN SUPERBLK")) { bcopy((char *)&cstotal, (char *)&sblock.fs_cstotal, sizeof *cs); sblock.fs_ronly = 0; sblock.fs_fmod = 0; sbdirty(); } }
int main(void) { int sfd, cfd, epfd, nfds; struct epoll_event ctlevt, events[MAX_EVENT_NUM], *p_evts; struct sockaddr_un sun; socklen_t sunlen; char str[STR_LENGTH]; int ii; sfd = socket( AF_UNIX, SOCK_STREAM, 0); /* protocol */ if( sfd < 0) { errexit(__func__, __LINE__); } memset( &sun, 0, sizeof(sun)); sun.sun_family = AF_UNIX; strncpy( sun.sun_path, SOCKET_PATH, sizeof(sun.sun_path) - 1); if( bind( sfd, (struct sockaddr*)&sun, sizeof(sun)) < 0) { errexit(__func__, __LINE__); } setSignalHandler(); /* if SIGINT then unlink(SOCKET_PATH) */ if( listen( sfd, LISTEN_BACKLOG) < 0) { errexit(__func__, __LINE__); } epfd = epoll_create1(0); if(epfd < 0) { errexit(__func__, __LINE__); } ctlevt.events = EPOLLIN; ctlevt.data.fd = sfd; if( epoll_ctl( epfd, EPOLL_CTL_ADD, sfd, &ctlevt) < 0) { errexit(__func__, __LINE__); } printf("epoll_wait() then waiting...\n"); nfds = epoll_wait( epfd, events, MAX_EVENT_NUM, -1); /* timeout: unlimited*/ for(ii = 0; ii < nfds; ii++) { p_evts = &events[ii]; if(p_evts->data.fd == sfd) { sunlen = sizeof(sun); cfd = accept( sfd, (struct sockaddr*)&sun, &sunlen); if( cfd < 0) { errexit(__func__, __LINE__); } printf("accept() ok.\n"); } } read( cfd, str, sizeof(str)); printf("[s] %s\n", str); strncpy( str, "HELLO", sizeof(str) - 1); write( cfd, str, sizeof(str)); close(sfd); close(cfd); unlink(SOCKET_PATH); printf("[s] bye\n"); return 0; }
/************************************************************************* * This function takes a graph and creates a sequence of coarser graphs **************************************************************************/ GraphType *Coarsen2Way(CtrlType *ctrl, GraphType *graph) { int clevel; GraphType *cgraph; IFSET(ctrl->dbglvl, DBG_TIME, starttimer(ctrl->CoarsenTmr)); cgraph = graph; /* The following is ahack to allow the multiple bisections to go through with correct coarsening */ if (ctrl->CType > 20) { clevel = 1; ctrl->CType -= 20; } else clevel = 0; do { IFSET(ctrl->dbglvl, DBG_COARSEN, printf("%6d %7d [%d] [%d %d]\n", cgraph->nvtxs, cgraph->nedges, ctrl->CoarsenTo, ctrl->maxvwgt, (cgraph->vwgt ? idxsum(cgraph->nvtxs, cgraph->vwgt) : cgraph->nvtxs))); if (cgraph->adjwgt) { switch (ctrl->CType) { case MATCH_RM: Match_RM(ctrl, cgraph); break; case MATCH_HEM: if (clevel < 1) Match_RM(ctrl, cgraph); else Match_HEM(ctrl, cgraph); break; case MATCH_SHEM: if (clevel < 1) Match_RM(ctrl, cgraph); else Match_SHEM(ctrl, cgraph); break; case MATCH_SHEMKWAY: Match_SHEM(ctrl, cgraph); break; default: errexit("Unknown CType: %d\n", ctrl->CType); } } else { Match_RM_NVW(ctrl, cgraph); } cgraph = cgraph->coarser; clevel++; } while (cgraph->nvtxs > ctrl->CoarsenTo && cgraph->nvtxs < COARSEN_FRACTION2*cgraph->finer->nvtxs && cgraph->nedges > cgraph->nvtxs/2); IFSET(ctrl->dbglvl, DBG_COARSEN, printf("%6d %7d [%d] [%d %d]\n", cgraph->nvtxs, cgraph->nedges, ctrl->CoarsenTo, ctrl->maxvwgt, (cgraph->vwgt ? idxsum(cgraph->nvtxs, cgraph->vwgt) : cgraph->nvtxs))); IFSET(ctrl->dbglvl, DBG_TIME, stoptimer(ctrl->CoarsenTmr)); return cgraph; }