int main(int argc,char *argv[]) { char pdb_name[FILENAME_LEN]; char dom_name[FILENAME_LEN], full_dom_name[FILENAME_LEN]; char hhb_name[FILENAME_LEN], nnb_name[FILENAME_LEN]; char root_name[FILENAME_LEN], full_root_name[FILENAME_LEN]; char chain1, chain2; int natoms, nresidues; int by_domain; int domain1, domain2; /* Get the PDB file name from the command-line arguments*/ get_command_arguments(argv,argc - 1,pdb_name,&chain1,&chain2,&by_domain, &domain1,&domain2); /* Get all the associated filenames */ get_filename(pdb_name,dom_name,".dom",root_name,full_root_name); get_filename(pdb_name,hhb_name,".hhb",root_name,full_root_name); get_filename(pdb_name,nnb_name,".nnb",root_name,full_root_name); /* Get full name of domains .dom file if it is in the same directory as the PDB file */ strcpy(full_dom_name,full_root_name); strcat(full_dom_name,".dom"); /* Read in the .dom file to get the domain information */ if (by_domain == TRUE) get_domains(dom_name,full_dom_name,domain1,domain2); /* Read through pdb file, storing all residues */ read_pdb(pdb_name,&natoms,&nresidues,chain1,chain2,by_domain,domain1); /* Read in the required H-bonds from the .hhb file */ read_hbplus_file(hhb_name,HBONDS); /* Read in the required non-bonded interactions from the .nnb file */ read_hbplus_file(nnb_name,CONTACTS); /* Checks HETATMs from from HBPLUS linked list to keep any involved with both chains*/ check_waters(); /* Write out all the retained H-bonds to the output .hhb file */ strcpy(hhb_name,OUTFILE_2); output_hbplus_info(hhb_name,HBONDS); /* Write out all the retained non-bonded contacts to the output .nnb file */ strcpy(nnb_name,OUTFILE_3); output_hbplus_info(nnb_name,CONTACTS); /* Write out interacting residues to PDB output file */ strcpy(pdb_name,OUTFILE_1); pdb_out(pdb_name,root_name,chain1,chain2,by_domain,domain1,domain2); /* Finish */ return(0); }
/*****-----functional interface of LongMode-Paging----*****/ bool LongModePaging::map_page_table(Address addr , void* pg_ptr , bool pbuffer) { //std::cout<<"map:"<<std::hex<<addr<<std::endl; unsigned pml4,pdp,pd,pt; get_domains(addr , pml4 , pdp , pd , pt , mode); unsigned buffer_entry_id = get_buffer_table_off(addr,buffer_table_shift,mode); assert( (pml4!=(unsigned)(-1)) && (pdp!=(unsigned)(-1))); PageTable* table; if( mode == LongMode_Normal) { assert( (pd!=(unsigned)(-1)) &&(pt!=(unsigned)(-1))); table = allocate_page_table(pml4,pdp,pd); if( !table ) { debug_printf("allocate page table for LongMode_Normal failed!"); return false; } if( pbuffer) { //std::cout<<"extend one buffer map"<<std::endl; extend_one_buffer_map(addr,table,pg_ptr , pt, buffer_entry_id, buffer_table_entry_num); } else { validate_entry(table , pt , pg_ptr); } } else if( mode == LongMode_Middle ) { table = allocate_page_directory( pml4 , pdp); if(!table) { debug_printf("allocate page directory for LongMode_Middle failed!"); return false; } if( pbuffer ) extend_one_buffer_map(addr , table , pg_ptr , pd , buffer_entry_id , buffer_table_entry_num); else validate_entry( table,pd, pg_ptr); } else if( mode == LongMode_Huge ) { table = allocate_page_directory_pointer(pml4); if(!table) { debug_printf("allocate page directory pointer for LongMode_Huge failed!"); return false; } if(pbuffer) extend_one_buffer_map(addr , table ,pg_ptr, pdp,buffer_entry_id , buffer_table_entry_num); else validate_entry(table,pdp,pg_ptr); } return true; }
bool LongModePaging::remove_page_table(Address addr , Address size) { assert(mode==LongMode_Normal); if( addr&0x1fffff ) { debug_printf("address must align with 2MB"); return false; } unsigned pml4_entry , pdp_entry , pd_entry , pt_entry; get_domains(addr , pml4_entry , pdp_entry ,pd_entry, pt_entry , mode); unsigned page_table_num = (size+0x1fffff)>>21; for( unsigned i=0; i<page_table_num ;i++) remove_page_table( pml4_entry , pdp_entry , pd_entry+i); return true; }
bool LongModePaging::unmap_page_table( Address addr) { unsigned pml4_id,pdp_id,pd_id,pt_id; std::vector<unsigned> entry_id_vec(4); get_domains(addr , pml4_id , pdp_id , pd_id , pt_id , mode); entry_id_vec[0]=pml4_id; entry_id_vec[1]=pdp_id; entry_id_vec[2]=pd_id; PageTable* table = NULL; //point to page directory pointer table if( mode == LongMode_Normal) { table = get_tables(3, entry_id_vec); if( !table ) { debug_printf("didn't find entry indexed with %ld !",addr); return false; } invalidate_page(table,pt_id); } else if( mode == LongMode_Middle ) { table = get_tables(2,entry_id_vec); if( !table) { debug_printf("didn't find entry indexed with %ld !",addr); return false; } invalidate_page( table,pd_id); } else if( mode == LongMode_Huge) { table = get_tables(1,entry_id_vec); if(!table) { debug_printf("didn't find entry indexed with %ld !",addr); return false; } invalidate_page(table,pdp_id); } return false; }
/*--------------------------------------------------------*/ int main(int argc, char *argv[]) { char *parfname, *instrname, *maskname, *reffname, *imgfname, **inpfname, **outfname, **kerfname; unsigned short *mask0, *mask1, *flag0, *flag1; int *indx, nsec_x, nsec_y, isec_x, isec_y, x_off, y_off, mode, deg[MAX_NCOMP], i, k, nclip, npix, nim, ntab, nkeep; long int imglen, buflen, veclen, intlen, matlen, usblen, lomlen, lovlen, tablen, domlen, srtlen, *headlen, mheadlen, rheadlen; float *im, *imref, *imdif, sig[MAX_NCOMP], *sort_buf; double **vecs, **mat, *vec, **tab00, **wxy, *ker_norm, chi2_n, good_area, total_area, parity; DOM_TABS *domp; PARAMS par; /**************************************************************************/ imref = imdif = NULL; mask0 = mask1 = NULL; flag0 = flag1 = NULL; indx = NULL; vec = NULL; vecs = mat = NULL; tab00 = wxy = NULL; sort_buf = NULL; good_area = 0.0; domp = 0; /*** argument handling ***/ if (argc != 6) usage(); parfname = argv[1]; instrname= argv[2]; maskname = argv[3]; reffname = argv[4]; imgfname = argv[5]; /**************************************************************************/ /*** get parameters ***/ /**************************************************************************/ par.deg = deg; par.sig = sig; get_params(parfname, instrname, &par); if (par.verbose > 3) { printf("parfname: %s\n", parfname); printf("instrname: %s\n", instrname); printf("maskname: %s\n", maskname); printf("reffname: %s\n", reffname); printf("imgfname: %s\n", imgfname); printf("--------------\n"); } /*** get the list of input, output and kernel files ***/ if (par.verbose > 2) printf("Reading '%s'\n", imgfname); nim=read_list(par, imgfname, &inpfname, &outfname, &kerfname); if (par.verbose > 2) printf("%d file-names read read\n", nim); for (i=1; i<par.ncomp; i++) { par.deg[i] = par.deg[i-1] + par.deg_inc; par.sig[i] = par.sig[i-1] * par.sig_inc; } par.nx += 2*par.kerhw; par.ny += 2*par.kerhw; par.sdeg = par.wdeg; if (par.bdeg > par.wdeg) par.sdeg = par.bdeg; par.nwxy = (par.wdeg+1)*(par.wdeg+2)/2; par.nspat = (par.sdeg+1)*(par.sdeg+2)/2; par.nbkg = (par.bdeg+1)*(par.bdeg+2)/2; par.nvecs = par.nbkg; for (i=0; i<par.ncomp; i++) par.nvecs += (par.deg[i]+1)*(par.deg[i]+2)/2; par.ntot = par.nvecs + (par.nvecs - par.nbkg - 1)*(par.nwxy - 1); par.ndom = par.ndom_x*par.ndom_y; ntab = par.nvecs-par.nbkg+par.nspat; if (par.verbose) printf("\t %d image(s) to process\n\n", nim); /**************************************************************************/ /*** get memory ***/ /**************************************************************************/ imglen = par.nx*par.ny*sizeof(float); buflen = par.nx*par.ny*sizeof(double); matlen = par.ntot*sizeof(double *); veclen = par.ntot*sizeof(double); usblen = par.nx*par.ny*sizeof(unsigned short); tablen = ntab*sizeof(double *); lomlen = par.nvecs*sizeof(double *); lovlen = par.nvecs*sizeof(double); domlen = par.ndom*sizeof(DOM_TABS); srtlen = par.ndom*sizeof(float); intlen = par.ndom*sizeof(int); if (par.ntot > par.ndom) intlen = par.ntot*sizeof(int); if (!(im = (float *)malloc(imglen))) errmess("malloc(im)"); if (!(imref = (float *)malloc(imglen))) errmess("malloc(imref)"); if (!(imdif = (float *)malloc(imglen))) errmess("malloc(imdif)"); if (!(mat = (double **)malloc(matlen))) errmess("malloc(mat)"); if (!(tab00 = (double **)malloc(tablen))) errmess("malloc(tab00)"); if (!(vecs = (double **)malloc(tablen))) errmess("malloc(vecs)"); if (!(wxy = (double **)malloc(tablen))) errmess("malloc(wxy)"); if (!(domp = (DOM_TABS *)malloc(domlen))) errmess("malloc(DOM_TABS)"); if (!(sort_buf = (float *)malloc(srtlen))) errmess("malloc(sort_buf)"); for (i=0; i<ntab; i++) if (!(tab00[i] = (double *)malloc(buflen))) errmess("malloc(tab00[i])"); for (k=0; k<par.ndom; k++) { if (!(domp[k].mat0 = (double **)malloc(lomlen))) errmess("malloc(domp[k].mat0)"); if (!(domp[k].mat1 = (double **)malloc(lomlen))) errmess("malloc(domp[k].mat1)"); if (!(domp[k].mat = (double **)malloc(lomlen))) errmess("malloc(domp[k].mat)"); if (!(domp[k].vec0 = (double *)malloc(lovlen))) errmess("malloc(domp[k].vec0)"); if (!(domp[k].vec = (double *)malloc(lovlen))) errmess("malloc(domp[k].vec)"); for (i=0; i<par.nvecs; i++) { if (!(domp[k].mat0[i] = (double *)malloc(lovlen))) errmess("malloc(domp[k].mat0[i])"); if (!(domp[k].mat1[i] = (double *)malloc(lovlen))) errmess("malloc(domp[k].mat1[i])"); if (!(domp[k].mat[i] = (double *)malloc(lovlen))) errmess("malloc(domp[k].mat[i])"); } } /* mat is indexed from 1 to n for use with numerical recipes ! */ for (i=0; i<par.ntot; i++) { if (!(mat[i] = (double *)malloc(veclen))) errmess("malloc(mat[i])"); mat[i]--; } mat--; if (!(vec = (double *)malloc(veclen))) errmess("malloc(vec)"); if (!(indx = (int *)malloc(intlen))) errmess("malloc(indx)"); if (!(mask0 = (unsigned short *)malloc(usblen))) errmess("malloc(mask0)"); if (!(mask1 = (unsigned short *)malloc(usblen))) errmess("malloc(mask1)"); if (!(flag0 = (unsigned short *)malloc(usblen))) errmess("malloc(flag0)"); if (!(flag1 = (unsigned short *)malloc(usblen))) errmess("malloc(flag1)"); if (!(headlen=(long *)calloc(nim, sizeof(long)))) errmess("calloc(headlen)"); if (!(ker_norm=(double *)calloc(nim, sizeof(double)))) errmess("calloc(ker_norm)"); /**************************************************************************/ /**************************************************************************/ /* get information about header sizes */ mheadlen=get_headlen(maskname); rheadlen=get_headlen(reffname); init_difimages(inpfname, outfname, headlen, nim, par); /**************************************************************************/ if (par.verbose > 4) { printf("par.nx0= %d par.ny0 = %d\n", par.nx0, par.ny0); printf("par.kerhw= %d\n", par.kerhw); printf("par.nx= %d par.ny = %d\n", par.nx, par.ny); } nsec_x = (par.nx0 - 2*par.kerhw)/(par.nx - 2*par.kerhw); nsec_y = (par.ny0 - 2*par.kerhw)/(par.ny - 2*par.kerhw); /**************************************************************************/ /*** main loop over sections of each image ***/ /**************************************************************************/ if (par.verbose > 4) printf("main loop over sections: nsec_x= %d nsec_y= %d\n", nsec_x, nsec_y); for (isec_x=0; isec_x<nsec_x; isec_x++) { for (isec_y=0; isec_y<nsec_y; isec_y++) { y_off = isec_y*(par.ny - 2*par.kerhw); x_off = isec_x*(par.nx - 2*par.kerhw); mode = (int)( isec_x || isec_y ); if (par.verbose > 4) printf("isec_x= %d isec_y= %d mode= %d\n", isec_x, isec_y, mode); read_sector(maskname, mheadlen, par.nx0, par.ny0, x_off, y_off, (char *)mask0, sizeof(unsigned short), par.nx, par.ny); read_sector(reffname, rheadlen, par.nx0, par.ny0, x_off, y_off, (char *)imref, sizeof(float), par.nx, par.ny); make_vectors(imref, tab00, vecs, wxy, par); mask_badpix(imref, mask0, flag0, 0, par); get_domains(imref, mask0, domp, par, &par.ndom); make_domains(imref, mask0, vecs, domp, par); total_area = (2*par.domhw + 1); total_area *= total_area*par.ndom; /**********************************************/ /*** loop over images for a given section ***/ /**********************************************/ for (i=0; i<nim; i++) { if (par.verbose >= VERB_MED) printf("\nSection [%d,%d] of image %d : %s\n", isec_x+1, isec_y+1, i+1, inpfname[i]); read_sector(inpfname[i], headlen[i], par.nx0, par.ny0, x_off, y_off, (char *)im, sizeof(float), par.nx, par.ny); mask_badpix(im, mask1, flag1, 1, par); npix = clean_domains(im, imref, mask0, mask1, vecs, domp, par); /*** sigma clipping ***/ chi2_n = BIG_FLOAT; if (par.verbose >= VERB_MED) { printf("\nLocal sigma clipping of domains:\n"); printf(" iteration chi2/dof N(clip) N(fit)\n"); } for (k=0; k<=par.n_iter+1; k++) { good_area = npix/total_area; if (good_area < par.min_area) break; clone_domains(domp, par.ndom, par.nvecs); /**************************/ if (k > 0) { nclip = local_clip(im, imref, mask1, vecs, wxy, vec, domp, par, &chi2_n, &npix); if (par.verbose >= VERB_MED) printf("%6d\t%14.4f\t%9d\t%7d\n", k-1, par.gain*chi2_n, nclip, npix); } /**************************/ expand_matrix(mat, vec, wxy, domp, par); ludcmp(mat, par.ntot, indx-1, &parity); lubksb(mat, par.ntot, indx-1, vec-1); } if (par.verbose >= VERB_MED) { printf("\nSigma clipping of domain distribution:\n"); printf("iteration median chi2/dof sigma N(good)\n"); } nkeep = par.ndom; for (k=1; k<=par.n_iter_dom && nkeep>=par.min_nkeep; k++) nkeep = clip_domains(domp, sort_buf, indx, k, &chi2_n, par); /*** sigma clipping ends ***/ chi2_n *= par.gain; /*** final solution ***/ if (good_area < par.min_area) { printf("\nFailed for section [%d,%d] of image %d : %s\n", isec_x+1, isec_y+1, i+1, inpfname[i]); printf("*** [ good_area= %f < %f ] ***\n", good_area, par.min_area); } else if (chi2_n > par.max_chi2) { printf("\nFailed for section [%d,%d] of image %d : %s\n", isec_x+1, isec_y+1, i+1, inpfname[i]); printf("*** [ chi2_n= %f > %f ] ***\n", chi2_n, par.max_chi2); } else if (nkeep < par.min_nkeep) { printf("\nFailed for section [%d,%d] of image %d : %s\n", isec_x+1, isec_y+1, i+1, inpfname[i]); printf("*** [ nkeep= %d < %d ] ***\n", nkeep, par.min_nkeep); } else { expand_matrix(mat, vec, wxy, domp, par); ludcmp(mat, par.ntot, indx-1, &parity); lubksb(mat, par.ntot, indx-1, vec-1); spatial_convolve(im, imdif, vecs, wxy, vec, par); /*** output ***/ ker_norm[i] = vec[par.nbkg]; apply_norm(imdif, flag0, flag1, ker_norm[i], par.nx, par.ny, par.bad_value); write_sector(outfname[i], headlen[i], par.nx0, par.ny0, x_off, y_off, (char *)imdif, sizeof(float), par.nx, par.ny, par.kerhw); } if (par.verbose) write_kernel(kerfname[i], vec, nsec_x, nsec_y, mode, par, &chi2_n); } /**********************************************/ /*** loop over images ends ***/ /**********************************************/ } } /**********************************************/ /*** loop over sections ends ***/ /**********************************************/ if (par.verbose >= VERB_HIGH) { printf("\nKernel norms:\n\n"); for (i=0; i<nim; i++) printf("%s \t %8.5f\n", kerfname[i], ker_norm[i]); printf("\n"); } for (i=0; i<nim; i++) { free(inpfname[i]); free(outfname[i]); free(kerfname[i]); } free(inpfname); free(outfname); free(kerfname); free(headlen); free(ker_norm); return(0); }
Address LongModePaging::access(MemReq &req) { Address addr = req.lineAddr; unsigned pml4_id,pdp_id,pd_id,pt_id; bool pbuffer = false; get_domains(addr,pml4_id,pdp_id,pd_id,pt_id,mode); //point to page table pointer table PageTable* pdp_ptr = get_next_level_address<PageTable>( pml4,pml4_id ); req.cycle +=10; if( !pdp_ptr) { return PAGE_FAULT_SIG; } if( mode == LongMode_Huge) { pbuffer = point_to_buffer_table( (PageTable*)pdp_ptr,pdp_id); } //point to page or page directory void* ptr = get_next_level_address<void>(pdp_ptr,pdp_id ); req.cycle +=10; if( !ptr ) { return PAGE_FAULT_SIG; } if( mode == LongMode_Middle) { assert( pd_id != (unsigned)(-1) ); pbuffer = point_to_buffer_table((PageTable*)ptr,pd_id); debug_printf("point to dram buffer: %d",pbuffer); //point to page ptr = get_next_level_address<void>( (PageTable*)ptr,pd_id); req.cycle += 10; if( !ptr ) { return PAGE_FAULT_SIG; } } else if( mode == LongMode_Normal) { assert( pd_id != (unsigned)(-1)); assert( pt_id != (unsigned)(-1)); //point to page table ptr = get_next_level_address<void>((PageTable*)ptr,pd_id); req.cycle += 10; if( ptr ) pbuffer = point_to_buffer_table((PageTable*)ptr,pt_id); if( !ptr ) { return PAGE_FAULT_SIG; } //point to page or buffer table ptr = get_next_level_address<void>((PageTable*)ptr,pt_id); req.cycle +=10; if( !ptr ) { return PAGE_FAULT_SIG; } } bool set_dirty = false; if( req.type == SETDIRTY) set_dirty = true; bool write_back = false; uint32_t access_counter = 0; if( req.type==WRITEBACK) { access_counter = req.childId; write_back = true; } return get_block_id(req , addr , ptr, buffer_table_shift,mode, pbuffer ,set_dirty, write_back ,access_counter); }