00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 template<class T>
00014 void mdp_field<T>::load(char filename[],
00015 int processIO,
00016 mdp_int max_buffer_size,
00017 char *header,
00018 mdp_int header_size,
00019 mdp_int (*sort_x)(mdp_lattice&,mdp_int),
00020 int auto_switch_endianess) {
00021 mdp_int idx_gl, nvol_gl=lattice().nvol_gl, k;
00022 double mytime=mpi.time();
00023 int try_switch_endianess=false;
00024 if(ME==processIO) {
00025 mdp_int *buffer_size=new mdp_int[Nproc];
00026 mdp_array<T,3> large_buffer(Nproc,max_buffer_size,field_components);
00027 T *short_buffer=new T[field_components];
00028 int process;
00029 mdp_request request;
00030
00031 for(process=0; process<Nproc; process++) buffer_size[process]=0;
00032 printf("Loading file %s from process %i (buffer = %li sites)\n",
00033 filename, processIO, max_buffer_size);
00034 fflush(stdout);
00035 FILE *fp=fopen(filename, "rb");
00036 if(fp==0) error("Unable to open file");
00037
00038
00039 int i;
00040 if(strcmp(header,"NATIVE")==0) {
00041 error("NATIVE HEADER IN DEPRECATED FUNCTION NOT SUPPORTED ANY MORE");
00042 } else if(header!=0 && strcmp(header, "NOHEADER")!=0) {
00043 if(fread(header, sizeof(char), header_size, fp)!=
00044 header_size) error("Unable to read file header");
00045 }
00046
00047 for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
00048 process=where_global(idx_gl);
00049 if(process!=NOWHERE) {
00050 if(sort_x!=0)
00051 if(fseek(fp, sort_x(lattice(),idx_gl)*
00052 Tsize*field_components+header_size, SEEK_SET)<0)
00053 error("unexpected end of file");
00054 if((fread(short_buffer, Tsize, field_components, fp)-
00055 field_components)!=0)
00056 error("unexpected end of file");
00057 }
00058 if((process!=NOWHERE) && (process!=processIO)) {
00059 for(k=0; k<field_components; k++)
00060 large_buffer(process,buffer_size[process],k)=short_buffer[k];
00061 buffer_size[process]++;
00062 if(buffer_size[process]==max_buffer_size) {
00063 mpi.put(&(large_buffer(process,0,0)),
00064 max_buffer_size*field_components, process, request);
00065 mpi.wait(request);
00066 buffer_size[process]=0;
00067 }
00068 if(idx_gl==nvol_gl-1)
00069 for(process=0; process<Nproc; process++)
00070 if((process!=ME) &&
00071 (buffer_size[process]!=max_buffer_size) &&
00072 (buffer_size[process]>0)) {
00073 mpi.put(&(large_buffer(process,0,0)),
00074 buffer_size[process]*field_components,
00075 process, request);
00076 mpi.wait(request);
00077 }
00078 }
00079 if(process==processIO) {
00080 for(k=0; k<field_components; k++)
00081 *(m+lattice().lg[idx_gl]*field_components+k)=short_buffer[k];
00082 }
00083 }
00084 delete[] buffer_size;
00085 delete[] short_buffer;
00086 fclose(fp);
00087 } else {
00088 int process;
00089 mdp_int buffer_size=0, idx;
00090 mdp_int *local_index=new mdp_int[max_buffer_size];
00091 mdp_array<T,2> local_buffer(max_buffer_size,field_components);
00092 for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
00093 process=where_global(idx_gl);
00094 if(process==ME) {
00095 local_index[buffer_size]=lattice().lg[idx_gl];
00096 buffer_size++;
00097 }
00098 if((buffer_size==max_buffer_size) ||
00099 ((idx_gl==nvol_gl-1) && (buffer_size>0))) {
00100 mpi.get(&(local_buffer(0,0)), buffer_size*field_components, processIO);
00101 for(idx=0; idx<buffer_size; idx++)
00102 for(k=0; k<field_components; k++)
00103 *(m+local_index[idx]*field_components+k)=local_buffer(idx,k);
00104 buffer_size=0;
00105 }
00106 }
00107 delete[] local_index;
00108 }
00109 update();
00110 if(ME==0 && mdp_shutup==false) {
00111 printf("... Loading time: %f (sec)\n", mpi.time()-mytime);
00112 fflush(stdout);
00113 }
00114 if(try_switch_endianess==true && auto_switch_endianess==true) {
00115 if(ME==0) printf("Trying to switch endianess.");
00116 switch_endianess_4bytes();
00117 }
00118 }
00119
00120 template<class T>
00121 void mdp_field<T>::save(char filename[],
00122 int processIO,
00123 mdp_int max_buffer_size,
00124 char *header,
00125 mdp_int header_size,
00126 mdp_int (*sort_x)(mdp_lattice&,mdp_int),
00127 char *mode) {
00128 mdp_int idx_gl, nvol_gl=lattice().nvol_gl, k;
00129 double mytime=mpi.time();
00130 if(ME==processIO) {
00131 mdp_int *buffer_size=new mdp_int[Nproc];
00132 mdp_int *buffer_ptr =new mdp_int[Nproc];
00133 mdp_array<T,3> large_buffer(Nproc,max_buffer_size,field_components);
00134 T *short_buffer=new T[field_components];
00135 int process;
00136 for(process=0; process<Nproc; process++) buffer_ptr[process]=0;
00137 printf("Saving file %s from process %i (buffer = %li sites)\n",
00138 filename, processIO, max_buffer_size);
00139 fflush(stdout);
00140 FILE *fp=fopen(filename, mode);
00141 if(fp==0) error("Unable to open file");
00142
00143
00144
00145 int i;
00146 if(strcmp(header,"NATIVE")==0) {
00147 error("NATIVE HEADER IN DEPRECATED FUNCTION NOT SUPPORTED ANY MORE");
00148 } else if(header!=0 && strcmp(header, "NOHEADER")!=0) {
00149 if(fwrite(header, sizeof(char), header_size, fp)!=
00150 header_size) error("Unable to write file header");
00151 }
00152
00153 for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
00154 process=where_global(idx_gl);
00155 if((process!=NOWHERE) && (process!=processIO)) {
00156 if(buffer_ptr[process]==0) {
00157 mpi.get(buffer_size[process], process);
00158 mpi.get(&(large_buffer(process,0,0)),
00159 buffer_size[process]*field_components, process);
00160 }
00161 for(k=0; k<field_components; k++)
00162 short_buffer[k]=large_buffer(process,buffer_ptr[process],k);
00163 buffer_ptr[process]++;
00164 if(buffer_ptr[process]==buffer_size[process]) buffer_ptr[process]=0;
00165 }
00166 if(process==processIO) {
00167 for(k=0; k<field_components; k++)
00168 short_buffer[k]=*(m+lattice().lg[idx_gl]*field_components+k);
00169 }
00170 if(process!=NOWHERE) {
00171 if(sort_x!=0)
00172 if(fseek(fp, sort_x(lattice(),idx_gl)*
00173 Tsize*field_components+header_size, SEEK_SET)<0)
00174 error("unexpected end of file");
00175 if((fwrite(short_buffer, Tsize, field_components, fp)-
00176 field_components)!=0)
00177 error("I cannot write on the file. I am confused !?!?");
00178 }
00179 }
00180 if(strcmp(header,"NATIVE")==0)
00181 fprintf(fp, "\n\n [ MDP Standard File Format ]\n");
00182 delete[] buffer_size;
00183 delete[] buffer_ptr;
00184 delete[] short_buffer;
00185 fclose(fp);
00186 } else {
00187 int process;
00188 mdp_int buffer_size=0, idx, idx_gl;
00189 mdp_int *local_index=new mdp_int[max_buffer_size];
00190 mdp_array<T,2> local_buffer(max_buffer_size,field_components);
00191 mdp_request request;
00192 for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
00193 process=where_global(idx_gl);
00194 if(process==ME) {
00195 local_index[buffer_size]=lattice().lg[idx_gl];
00196 buffer_size++;
00197 }
00198 if((buffer_size==max_buffer_size) ||
00199 ((idx_gl==nvol_gl-1) && (buffer_size>0))) {
00200 for(idx=0; idx<buffer_size; idx++)
00201 for(k=0; k<field_components; k++)
00202 local_buffer(idx,k)=*(m+local_index[idx]*field_components+k);
00203 mpi.put(buffer_size, processIO, request);
00204 mpi.wait(request);
00205 mpi.put(&(local_buffer(0,0)), buffer_size*field_components,
00206 processIO, request);
00207 mpi.wait(request);
00208 buffer_size=0;
00209 }
00210 }
00211 delete[] local_index;
00212 }
00213 if(ME==0 && mdp_shutup==false) {
00214 printf("... Saving time: %f (sec)\n", mpi.time()-mytime);
00215 fflush(stdout);
00216 }
00217 }
00218
00219
