00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00014 bool mdp_default_user_read(FILE *fp,
00015 void* p,
00016 mdp_int psize,
00017 mdp_int header_size,
00018 mdp_int position,
00019 const mdp_lattice &lattice) {
00020 if(fseek(fp, position*psize+header_size, SEEK_SET) ||
00021 fread(p, psize,1, fp)!=1) return false;
00022 return true;
00023 }
00024
00025
00027 template<class T>
00028 bool mdp_field<T>::load(string filename,
00029 int processIO,
00030 mdp_int max_buffer_size,
00031 bool load_header,
00032 mdp_int skip_bytes,
00033 bool (*user_read)(FILE*, void*, mdp_int, mdp_int, mdp_int, const mdp_lattice&),
00034 bool try_swicth_endianess) {
00035
00036 filename=latest_file(filename);
00037 if(filename=="?") return false;
00038 mdp_int header_size=0;
00039 mdp_int idx_gl, nvol_gl=lattice().nvol_gl, k;
00040 mdp_int psize=field_components*Tsize;
00041 double mytime=mpi.time();
00042 bool reversed_header_endianess=false;
00043 struct stat statbuf;
00044 if(ME==processIO) {
00045 mdp_int *buffer_size=new mdp_int[Nproc];
00046 mdp_array<T,3> large_buffer(Nproc,max_buffer_size,field_components);
00047 T *short_buffer=new T[field_components];
00048 int process;
00049 mdp_request request;
00050
00051 for(process=0; process<Nproc; process++) buffer_size[process]=0;
00052 cout << "Loading file " << filename
00053 << " from process " << processIO
00054 << " (buffer = " << max_buffer_size << " sites)" << '\n';
00055 fflush(stdout);
00056 stat(filename.c_str(),&statbuf);
00057 int total_size = statbuf.st_size;
00058 FILE *fp=fopen(filename.c_str(), "rb");
00059 if(fp==0) error("Unable to open file");
00060
00061 int i;
00062 if(load_header) {
00063 mdp_field_file_header tmp_header;
00064 header_size=sizeof(mdp_field_file_header);
00065
00066 if(fseek(fp, skip_bytes, SEEK_SET) ||
00067 fread(&tmp_header, header_size, 1, fp)!=1) {
00068 fprintf(stderr,"mdp_field.load(): Unable to load file header\n");
00069 return false;
00070 }
00071
00072 reversed_header_endianess=switch_header_endianess(tmp_header);
00073
00074 cout << "reverse: " << reversed_header_endianess << endl;
00075
00076 if(tmp_header.endianess!=header.endianess)
00077 fprintf(stderr, "Unrecognized endianess... trying to read anyway\n");
00078
00079
00080 int actual_size = tmp_header.box[0];
00081 for(int d=1; d<tmp_header.ndim; d++) actual_size*=tmp_header.box[d];
00082 tmp_header.sites = actual_size;
00083 header_size += total_size-(tmp_header.bytes_per_site*actual_size+header_size);
00084
00085 if(tmp_header.ndim!=header.ndim) {
00086 fprintf(stderr,"mdp_field.load(): wrong ndim\n");
00087 return false;
00088 }
00089 for(i=0; i<lattice().ndim; i++)
00090 if(tmp_header.box[i]!=header.box[i]) {
00091 fprintf(stderr,"mdp_file.load(): wrong lattice size\n");
00092 return false;
00093 }
00094 if(tmp_header.bytes_per_site!=header.bytes_per_site) {
00095 fprintf(stderr, "mdp_file.load(): wrong type of field (%i bytes per site?)\n", tmp_header.bytes_per_site );
00096 return false;
00097 }
00098 if(tmp_header.sites!=header.sites) {
00099 fprintf(stderr,"mdp_field.load(): wrong number of sites\n");
00100 return false;
00101 }
00102 header=tmp_header;
00103
00104 }
00105
00106 skip_bytes+=header_size;
00107
00108
00109 for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
00110 process=where_global(idx_gl);
00111 if(process!=NOWHERE) {
00112 if(user_read) {
00113 if(!user_read(fp, short_buffer,
00114 field_components*Tsize,
00115 skip_bytes,
00116 idx_gl, lattice()))
00117 error("unexpected end of file");
00118 } else {
00119 if(fseek(fp, idx_gl*psize+skip_bytes, SEEK_SET) ||
00120 fread(short_buffer, psize, 1, fp)!=1)
00121 error("unexpected end of file");
00122 }
00123 }
00124 if((process!=NOWHERE) && (process!=processIO)) {
00125 for(k=0; k<field_components; k++)
00126 large_buffer(process,buffer_size[process],k)=short_buffer[k];
00127 buffer_size[process]++;
00128 if(buffer_size[process]==max_buffer_size) {
00129 mpi.put(&(large_buffer(process,0,0)),
00130 max_buffer_size*field_components, process, request);
00131 mpi.wait(request);
00132 buffer_size[process]=0;
00133 }
00134 if(idx_gl==nvol_gl-1)
00135 for(process=0; process<Nproc; process++)
00136 if((process!=ME) &&
00137 (buffer_size[process]!=max_buffer_size) &&
00138 (buffer_size[process]>0)) {
00139 mpi.put(&(large_buffer(process,0,0)),
00140 buffer_size[process]*field_components,
00141 process, request);
00142 mpi.wait(request);
00143 }
00144 }
00145 if(process==processIO) {
00146 for(k=0; k<field_components; k++)
00147 *(m+lattice().local(idx_gl)*field_components+k)=short_buffer[k];
00148 }
00149 }
00150 delete[] buffer_size;
00151 delete[] short_buffer;
00152 fclose(fp);
00153 } else {
00154 int process;
00155 mdp_int buffer_size=0, idx;
00156 mdp_int *local_index=new mdp_int[max_buffer_size];
00157 mdp_array<T,2> local_buffer(max_buffer_size,field_components);
00158 for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
00159 process=where_global(idx_gl);
00160 if(process==ME) {
00161 local_index[buffer_size]=lattice().local(idx_gl);
00162 buffer_size++;
00163 }
00164 if((buffer_size==max_buffer_size) ||
00165 ((idx_gl==nvol_gl-1) && (buffer_size>0))) {
00166 mpi.get(&(local_buffer(0,0)), buffer_size*field_components, processIO);
00167 for(idx=0; idx<buffer_size; idx++)
00168 for(k=0; k<field_components; k++)
00169 *(m+local_index[idx]*field_components+k)=local_buffer(idx,k);
00170 buffer_size=0;
00171 }
00172 }
00173 delete[] local_index;
00174 }
00175
00176 update();
00177 mpi.broadcast(reversed_header_endianess,processIO);
00178 if(try_swicth_endianess && reversed_header_endianess) {
00179 mpi << "swithing endiness...\n";
00180 #ifdef USE_DOUBLE_PRECISION
00181 switch_endianess_8bytes();
00182 #else
00183 switch_endianess_4bytes();
00184 #endif
00185 }
00186 if(ME==0 && mdp_shutup==false) {
00187 printf("... Loading time: %f (sec)\n", mpi.time()-mytime);
00188 fflush(stdout);
00189 }
00190 return true;
00191 }
00192
