mdp_field_load.h

Go to the documentation of this file.

bool mdp_default_user_read(FILE *fp,
                           void* p,
                           long psize,
                           long header_size,
                           long position,
                           const mdp_lattice &lattice) {
  if(fseek(fp, position*psize+header_size, SEEK_SET) ||
     fread(p, psize,1, fp)!=1) return false;
  return true;
}


template<class T>
bool mdp_field<T>::load(string filename, 
                        int processIO, 
                        long max_buffer_size, 
                        bool load_header,
                        long skip_bytes,
                        bool (*user_read)(FILE*, void*, long, long, long, const mdp_lattice&),
                        bool try_swicth_endianess) {

  long header_size=0;
  long idx_gl, nvol_gl=lattice().nvol_gl, k;
  long psize=field_components*Tsize;
  double mytime=mpi.time();
  bool reversed_header_endianess=false;
  if(ME==processIO) {
    long *buffer_size=new long[Nproc];
    mdp_array<T,3> large_buffer(Nproc,max_buffer_size,field_components);
    T *short_buffer=new T[field_components];
    int process;
    mdp_request request;

    for(process=0; process<Nproc; process++) buffer_size[process]=0;
    cout << "Loading file " << filename 
         << " from process " << processIO 
         << " (buffer = " << max_buffer_size << " sites)" << '\n'; 
    fflush(stdout);
    FILE *fp=fopen(filename.c_str(), "rb");
    if(fp==0) error("Unable to open file");
    
    int i;
    if(load_header) {
      mdp_field_file_header tmp_header;
      header_size=sizeof(mdp_field_file_header);
      if(fseek(fp, skip_bytes, SEEK_SET) || 
           fread(&tmp_header, header_size, 1, fp)!=1) {
        fprintf(stderr,"mdp_field.load(): Unable to load file header\n");
        return false;
      }
      
      reversed_header_endianess=switch_header_endianess(tmp_header);
      if(tmp_header.endianess!=header.endianess) 
        fprintf(stderr, "Unrecognized endianess... trying to read anyway\n");

      if(tmp_header.ndim!=header.ndim) {
        fprintf(stderr,"mdp_field.load(): wrong ndim\n");
        return false;
      }
      for(i=0; i<lattice().ndim; i++)  
        if(tmp_header.box[i]!=header.box[i]) {
          fprintf(stderr,"mdp_file.load(): wrong lattice size\n");
          return false;
        }
      if(tmp_header.bytes_per_site!=header.bytes_per_site) {
        fprintf(stderr, "mdp_file.load(): wrong type of field\n");
        return false;
      }
      if(tmp_header.sites!=header.sites) {
        fprintf(stderr,"mdp_field.load(): wrong number of sites\n");
        return false;
      }
      header=tmp_header;
    }
    
    skip_bytes+=header_size;
    
    for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
      process=where_global(idx_gl);
      if(process!=NOWHERE) {
          if(user_read) {
            if(!user_read(fp, short_buffer, 
                          field_components*Tsize, 
                          skip_bytes, 
                          idx_gl, lattice()))
              error("unexpected end of file");
          } else {
            if(fseek(fp, idx_gl*psize+skip_bytes, SEEK_SET) ||
               fread(short_buffer, psize, 1, fp)!=1) 
              error("unexpected end of file");
          }
      }
      if((process!=NOWHERE) && (process!=processIO)) {
        for(k=0; k<field_components; k++)
          large_buffer(process,buffer_size[process],k)=short_buffer[k];
        buffer_size[process]++;
        if(buffer_size[process]==max_buffer_size) {
            mpi.put(&(large_buffer(process,0,0)), 
                    max_buffer_size*field_components, process, request); 
            mpi.wait(request);
            buffer_size[process]=0;
        }
        if(idx_gl==nvol_gl-1) 
          for(process=0; process<Nproc; process++)
            if((process!=ME) && 
                 (buffer_size[process]!=max_buffer_size) &&
               (buffer_size[process]>0)) {
                mpi.put(&(large_buffer(process,0,0)), 
                        buffer_size[process]*field_components, 
                        process, request); 
                mpi.wait(request);
            }
      }
      if(process==processIO) {
          for(k=0; k<field_components; k++)
            *(m+lattice().local(idx_gl)*field_components+k)=short_buffer[k];
      }
    }
    delete[] buffer_size;
    delete[] short_buffer;
    fclose(fp);
  } else {
    int  process;
    long buffer_size=0, idx;
    long *local_index=new long[max_buffer_size];
    mdp_array<T,2> local_buffer(max_buffer_size,field_components);
    for(idx_gl=0; idx_gl<nvol_gl; idx_gl++) {
      process=where_global(idx_gl);
      if(process==ME) {
        local_index[buffer_size]=lattice().local(idx_gl);
        buffer_size++;
      }
      if((buffer_size==max_buffer_size) || 
         ((idx_gl==nvol_gl-1) && (buffer_size>0))) {
        mpi.get(&(local_buffer(0,0)), buffer_size*field_components, processIO);
        for(idx=0; idx<buffer_size; idx++)
          for(k=0; k<field_components; k++)
            *(m+local_index[idx]*field_components+k)=local_buffer(idx,k);
        buffer_size=0;
      }
    }
    delete[] local_index;
  }

  update();
  mpi.broadcast(reversed_header_endianess,processIO);
  if(try_swicth_endianess && reversed_header_endianess) 
    switch_endianess_4bytes();
 
  if(ME==0 && mdp_shutup==FALSE) {
    printf("... Loading time: %f (sec)\n", mpi.time()-mytime);
    fflush(stdout);
  }
  return true;
}

---