00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00014 bool mdp_default_user_write(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 fwrite(p, psize,1, fp)!=1) return false;
00022 return true;
00023 }
00024
00025
00027 template<class T>
00028 bool mdp_field<T>::save(string filename,
00029 int processIO,
00030 mdp_int max_buffer_size,
00031 bool save_header,
00032 mdp_int skip_bytes,
00033 bool (*user_write)(FILE*, void*, mdp_int, mdp_int, mdp_int, const mdp_lattice&)) {
00034
00035 filename=next_to_latest_file(filename);
00036
00037 mdp_int header_size=0;
00038 mdp_int psize=field_components*Tsize;
00039 mdp_int idx_gl, nvol_gl=lattice().nvol_gl, k;
00040 double mytime=mpi.time();
00041 header.reset();
00042 if(ME==processIO) {
00043 mdp_int *buffer_size=new mdp_int[Nproc];
00044 mdp_int *buffer_ptr =new mdp_int[Nproc];
00045 mdp_array<T,3> large_buffer(Nproc,max_buffer_size,field_components);
00046 T *short_buffer=new T[field_components];
00047 int process;
00048 for(process=0; process<Nproc; process++) buffer_ptr[process]=0;
00049 cout << "Saving file " << filename
00050 << " from process " << processIO
00051 << " (buffer = " << max_buffer_size << " sites)" << '\n';
00052 fflush(stdout);
00053 FILE *fp=fopen(filename.c_str(), "wb+");
00054 if(fp==0) error("Unable to open file");
00055
00056 header.set_time();
00057
00058 if(save_header) {
00059 header_size=sizeof(mdp_field_file_header);
00060 if(fseek(fp, skip_bytes, SEEK_SET) ||
00061 fwrite(&header, header_size, 1, fp)!=1)
00062 error("Unable to write file header");
00063 }
00064
00065 skip_bytes+=header_size;
00066
00067 for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
00068 process=where_global(idx_gl);
00069 if((process!=NOWHERE) && (process!=processIO)) {
00070 if(buffer_ptr[process]==0) {
00071 mpi.get(buffer_size[process], process);
00072 mpi.get(&(large_buffer(process,0,0)),
00073 buffer_size[process]*field_components, process);
00074 }
00075 for(k=0; k<field_components; k++)
00076 short_buffer[k]=large_buffer(process,buffer_ptr[process],k);
00077 buffer_ptr[process]++;
00078 if(buffer_ptr[process]==buffer_size[process]) buffer_ptr[process]=0;
00079 }
00080 if(process==processIO) {
00081 for(k=0; k<field_components; k++)
00082 short_buffer[k]=*(m+lattice().local(idx_gl)*field_components+k);
00083 }
00084 if(process!=NOWHERE) {
00085 if(user_write) {
00086 if(!user_write(fp, short_buffer,
00087 field_components*Tsize,
00088 skip_bytes,
00089 idx_gl, lattice()))
00090 error("propably out ofdisk space");
00091 } else {
00092 if(fseek(fp, idx_gl*psize+skip_bytes, SEEK_SET) ||
00093 fwrite(short_buffer, psize,1, fp)!=1)
00094 error("probably out of disk space");
00095 }
00096 }
00097 }
00098 delete[] buffer_size;
00099 delete[] buffer_ptr;
00100 delete[] short_buffer;
00101 fclose(fp);
00102 } else {
00103 int process;
00104 mdp_int buffer_size=0, idx, idx_gl;
00105 mdp_int *local_index=new mdp_int[max_buffer_size];
00106 mdp_array<T,2> local_buffer(max_buffer_size,field_components);
00107 mdp_request request;
00108 for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
00109 process=where_global(idx_gl);
00110 if(process==ME) {
00111 local_index[buffer_size]=lattice().local(idx_gl);
00112 buffer_size++;
00113 }
00114 if((buffer_size==max_buffer_size) ||
00115 ((idx_gl==nvol_gl-1) && (buffer_size>0))) {
00116 for(idx=0; idx<buffer_size; idx++)
00117 for(k=0; k<field_components; k++)
00118 local_buffer(idx,k)=*(m+local_index[idx]*field_components+k);
00119 mpi.put(buffer_size, processIO, request);
00120 mpi.wait(request);
00121 mpi.put(&(local_buffer(0,0)), buffer_size*field_components,
00122 processIO, request);
00123 mpi.wait(request);
00124 buffer_size=0;
00125 }
00126 }
00127 delete[] local_index;
00128 }
00129 if(ME==0 && mdp_shutup==false) {
00130 printf("... Saving time: %f (sec)\n", mpi.time()-mytime);
00131 fflush(stdout);
00132 }
00133 return true;
00134 }
