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);
}
