source: GenericIO.h @ 5d57155

Revision 5d57155, 16.3 KB checked in by Hal Finkel <hfinkel@…>, 7 years ago (diff)

Add support for float4 (and other homogeneous aggregates)
  • Property mode set to 100644
Line 
1/*
2 *                    Copyright (C) 2015, UChicago Argonne, LLC
3 *                               All Rights Reserved
4 *
5 *                               Generic IO (ANL-15-066)
6 *                     Hal Finkel, Argonne National Laboratory
7 *
8 *                              OPEN SOURCE LICENSE
9 *
10 * Under the terms of Contract No. DE-AC02-06CH11357 with UChicago Argonne,
11 * LLC, the U.S. Government retains certain rights in this software.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions are met:
15 *
16 *   1. Redistributions of source code must retain the above copyright notice,
17 *      this list of conditions and the following disclaimer.
18 *
19 *   2. Redistributions in binary form must reproduce the above copyright
20 *      notice, this list of conditions and the following disclaimer in the
21 *      documentation and/or other materials provided with the distribution.
22 *
23 *   3. Neither the names of UChicago Argonne, LLC or the Department of Energy
24 *      nor the names of its contributors may be used to endorse or promote
25 *      products derived from this software without specific prior written
26 *      permission.
27 *
28 * *****************************************************************************
29 *
30 *                                  DISCLAIMER
31 * THE SOFTWARE IS SUPPLIED “AS IS” WITHOUT WARRANTY OF ANY KIND.  NEITHER THE
32 * UNTED STATES GOVERNMENT, NOR THE UNITED STATES DEPARTMENT OF ENERGY, NOR
33 * UCHICAGO ARGONNE, LLC, NOR ANY OF THEIR EMPLOYEES, MAKES ANY WARRANTY,
34 * EXPRESS OR IMPLIED, OR ASSUMES ANY LEGAL LIABILITY OR RESPONSIBILITY FOR THE
35 * ACCURACY, COMPLETENESS, OR USEFULNESS OF ANY INFORMATION, DATA, APPARATUS,
36 * PRODUCT, OR PROCESS DISCLOSED, OR REPRESENTS THAT ITS USE WOULD NOT INFRINGE
37 * PRIVATELY OWNED RIGHTS.
38 *
39 * *****************************************************************************
40 */
41
42#ifndef GENERICIO_H
43#define GENERICIO_H
44
45#include <cstdlib>
46#include <vector>
47#include <string>
48#include <iostream>
49#include <limits>
50#include <stdint.h>
51
52#ifndef GENERICIO_NO_MPI
53#include <mpi.h>
54#else
55#include <fstream>
56#endif
57
58#include <unistd.h>
59
60namespace gio {
61
62class GenericFileIO {
63public:
64  virtual ~GenericFileIO() {}
65
66public:
67  virtual void open(const std::string &FN, bool ForReading = false) = 0;
68  virtual void setSize(size_t sz) = 0;
69  virtual void read(void *buf, size_t count, off_t offset,
70                    const std::string &D) = 0;
71  virtual void write(const void *buf, size_t count, off_t offset,
72                     const std::string &D) = 0;
73
74protected:
75  std::string FileName;
76};
77
78#ifndef GENERICIO_NO_MPI
79class GenericFileIO_MPI : public GenericFileIO {
80public:
81  GenericFileIO_MPI(const MPI_Comm &C) : FH(MPI_FILE_NULL), Comm(C) {}
82  virtual ~GenericFileIO_MPI();
83
84public:
85  virtual void open(const std::string &FN, bool ForReading = false);
86  virtual void setSize(size_t sz);
87  virtual void read(void *buf, size_t count, off_t offset, const std::string &D);
88  virtual void write(const void *buf, size_t count, off_t offset, const std::string &D);
89
90protected:
91  MPI_File FH;
92  MPI_Comm Comm;
93};
94
95class GenericFileIO_MPICollective : public GenericFileIO_MPI {
96public:
97  GenericFileIO_MPICollective(const MPI_Comm &C) : GenericFileIO_MPI(C) {}
98
99public:
100  void read(void *buf, size_t count, off_t offset, const std::string &D);
101  void write(const void *buf, size_t count, off_t offset, const std::string &D);
102};
103#endif
104
105class GenericFileIO_POSIX : public GenericFileIO {
106public:
107  GenericFileIO_POSIX() : FH(-1) {}
108  ~GenericFileIO_POSIX();
109
110public:
111  void open(const std::string &FN, bool ForReading = false);
112  void setSize(size_t sz);
113  void read(void *buf, size_t count, off_t offset, const std::string &D);
114  void write(const void *buf, size_t count, off_t offset, const std::string &D);
115
116protected:
117  int FH;
118};
119
120namespace detail {
121// A standard enable_if idiom (we include our own here for pre-C++11 support).
122template <bool B, typename T = void>
123struct enable_if {};
124
125template <typename T>
126struct enable_if<true, T> { typedef T type; };
127
128// A SFINAE-based trait to detect whether a type has a member named x. This is
129// designed to work both with structs/classes and also with OpenCL-style vector
130// types.
131template <typename T>
132class has_x {
133  typedef char yes[1];
134  typedef char no[2];
135
136  template <typename C>
137  static yes &test(char(*)[sizeof((*((C *) 0)).x)]);
138
139  template <typename C>
140  static no &test(...);
141
142public:
143  enum { value = sizeof(test<T>(0)) == sizeof(yes) };
144};
145
146// A SFINAE-based trait to detect whether a type is array-like (i.e. supports
147// the [] operator).
148template <typename T>
149class is_array {
150  typedef char yes[1];
151  typedef char no[2];
152
153  template <typename C>
154  static yes &test(char(*)[sizeof((*((C *) 0))[0])]);
155
156  template <typename C>
157  static no &test(...);
158
159public:
160  enum { value = sizeof(test<T>(0)) == sizeof(yes) };
161};
162} // namespace detail
163
164class GenericIO {
165public:
166  enum VariableFlags {
167    VarHasExtraSpace =  (1 << 0), // Note that this flag indicates that the
168                                  // extra space is available, but the GenericIO
169                                  // implementation is required to
170                                  // preserve its contents.
171    VarIsPhysCoordX  =  (1 << 1),
172    VarIsPhysCoordY  =  (1 << 2),
173    VarIsPhysCoordZ  =  (1 << 3),
174    VarMaybePhysGhost = (1 << 4)
175  };
176
177  struct VariableInfo {
178    VariableInfo(const std::string &N, std::size_t S, bool IF, bool IS,
179                 bool PCX, bool PCY, bool PCZ, bool PG, std::size_t ES = 0)
180      : Name(N), Size(S), IsFloat(IF), IsSigned(IS),
181        IsPhysCoordX(PCX), IsPhysCoordY(PCY), IsPhysCoordZ(PCZ),
182        MaybePhysGhost(PG), ElementSize(ES ? ES : S) {}
183
184    std::string Name;
185    std::size_t Size;
186    bool IsFloat;
187    bool IsSigned;
188    bool IsPhysCoordX, IsPhysCoordY, IsPhysCoordZ;
189    bool MaybePhysGhost;
190    std::size_t ElementSize;
191  };
192
193public:
194  class Variable {
195  private:
196    template <typename ET>
197    void deduceTypeInfoFromElement(ET *) {
198      ElementSize = sizeof(ET);
199      IsFloat = !std::numeric_limits<ET>::is_integer;
200      IsSigned = std::numeric_limits<ET>::is_signed;
201    }
202
203    // There are specializations here to handle array types
204    // (e.g. typedef float float4[4];), struct types
205    // (e.g. struct float4 { float x, y, z, w; };), and scalar types.
206    // Builtin vector types
207    // (e.g. typedef float float4 __attribute__((ext_vector_type(4)));) should
208    // also work.
209    template <typename T>
210    typename detail::enable_if<detail::is_array<T>::value, void>::type
211    deduceTypeInfo(T *D) {
212      Size = sizeof(T);
213      deduceTypeInfoFromElement(&(*D)[0]);
214    }
215
216    template <typename T>
217    typename detail::enable_if<detail::has_x<T>::value &&
218                               !detail::is_array<T>::value, void>::type
219    deduceTypeInfo(T *D) {
220      Size = sizeof(T);
221      deduceTypeInfoFromElement(&(*D).x);
222    }
223
224    template <typename T>
225    typename detail::enable_if<!detail::has_x<T>::value &&
226                               !detail::is_array<T>::value, void>::type
227    deduceTypeInfo(T *D) {
228      Size = sizeof(T);
229      deduceTypeInfoFromElement(D);
230    }
231
232  public:
233    template <typename T>
234    Variable(const std::string &N, T* D, unsigned Flags = 0)
235      : Name(N), Data((void *) D), HasExtraSpace(Flags & VarHasExtraSpace),
236        IsPhysCoordX(Flags & VarIsPhysCoordX),
237        IsPhysCoordY(Flags & VarIsPhysCoordY),
238        IsPhysCoordZ(Flags & VarIsPhysCoordZ),
239        MaybePhysGhost(Flags & VarMaybePhysGhost) {
240      deduceTypeInfo(D);
241    }
242
243    template <typename T>
244    Variable(const std::string &N, std::size_t NumElements, T* D,
245             unsigned Flags = 0)
246      : Name(N), Data((void *) D), HasExtraSpace(Flags & VarHasExtraSpace),
247        IsPhysCoordX(Flags & VarIsPhysCoordX),
248        IsPhysCoordY(Flags & VarIsPhysCoordY),
249        IsPhysCoordZ(Flags & VarIsPhysCoordZ),
250        MaybePhysGhost(Flags & VarMaybePhysGhost) {
251      deduceTypeInfoFromElement(D);
252      Size = ElementSize*NumElements;
253    }
254
255    Variable(const VariableInfo &VI, void *D, unsigned Flags = 0)
256      : Name(VI.Name), Size(VI.Size), IsFloat(VI.IsFloat),
257        IsSigned(VI.IsSigned), Data(D),
258        HasExtraSpace(Flags & VarHasExtraSpace),
259        IsPhysCoordX((Flags & VarIsPhysCoordX) || VI.IsPhysCoordX),
260        IsPhysCoordY((Flags & VarIsPhysCoordY) || VI.IsPhysCoordY),
261        IsPhysCoordZ((Flags & VarIsPhysCoordZ) || VI.IsPhysCoordZ),
262        MaybePhysGhost((Flags & VarMaybePhysGhost) || VI.MaybePhysGhost),
263        ElementSize(VI.ElementSize) {}
264
265    std::string Name;
266    std::size_t Size;
267    bool IsFloat;
268    bool IsSigned;
269    void *Data;
270    bool HasExtraSpace;
271    bool IsPhysCoordX, IsPhysCoordY, IsPhysCoordZ;
272    bool MaybePhysGhost;
273    std::size_t ElementSize;
274  };
275
276public:
277  enum FileIO {
278    FileIOMPI,
279    FileIOPOSIX,
280    FileIOMPICollective
281  };
282
283#ifndef GENERICIO_NO_MPI
284  GenericIO(const MPI_Comm &C, const std::string &FN, unsigned FIOT = -1)
285    : NElems(0), FileIOType(FIOT == (unsigned) -1 ? DefaultFileIOType : FIOT),
286      Partition(DefaultPartition), Comm(C), FileName(FN), Redistributing(false),
287      DisableCollErrChecking(false), SplitComm(MPI_COMM_NULL) {
288    std::fill(PhysOrigin, PhysOrigin + 3, 0.0);
289    std::fill(PhysScale,  PhysScale + 3, 0.0);
290  }
291#else
292  GenericIO(const std::string &FN, unsigned FIOT = -1)
293    : NElems(0), FileIOType(FIOT == (unsigned) -1 ? DefaultFileIOType : FIOT),
294      Partition(DefaultPartition), FileName(FN), Redistributing(false),
295      DisableCollErrChecking(false) {
296    std::fill(PhysOrigin, PhysOrigin + 3, 0.0);
297    std::fill(PhysScale,  PhysScale + 3, 0.0);
298  }
299#endif
300
301  ~GenericIO() {
302    close();
303
304#ifndef GENERICIO_NO_MPI
305    if (SplitComm != MPI_COMM_NULL)
306      MPI_Comm_free(&SplitComm);
307#endif
308  }
309
310public:
311  std::size_t requestedExtraSpace() const {
312    return 8;
313  }
314
315  void setNumElems(std::size_t E) {
316    NElems = E;
317
318#ifndef GENERICIO_NO_MPI
319    int IsLarge = E >= CollectiveMPIIOThreshold;
320    int AllIsLarge;
321    MPI_Allreduce(&IsLarge, &AllIsLarge, 1, MPI_INT, MPI_SUM, Comm);
322    if (!AllIsLarge)
323      FileIOType = FileIOMPICollective;
324#endif
325  }
326
327  void setPhysOrigin(double O, int Dim = -1) {
328    if (Dim >= 0)
329      PhysOrigin[Dim] = O;
330    else
331      std::fill(PhysOrigin, PhysOrigin + 3, O);
332  }
333
334  void setPhysScale(double S, int Dim = -1) {
335    if (Dim >= 0)
336      PhysScale[Dim] = S;
337    else
338      std::fill(PhysScale,  PhysScale + 3, S);
339  }
340
341  template <typename T>
342  void addVariable(const std::string &Name, T *Data,
343                   unsigned Flags = 0) {
344    Vars.push_back(Variable(Name, Data, Flags));
345  }
346
347  template <typename T, typename A>
348  void addVariable(const std::string &Name, std::vector<T, A> &Data,
349                   unsigned Flags = 0) {
350    T *D = Data.empty() ? 0 : &Data[0];
351    addVariable(Name, D, Flags);
352  }
353
354  void addVariable(const VariableInfo &VI, void *Data,
355                   unsigned Flags = 0) {
356    Vars.push_back(Variable(VI, Data, Flags));
357  }
358
359  template <typename T>
360  void addScalarizedVariable(const std::string &Name, T *Data,
361                             std::size_t NumElements, unsigned Flags = 0) {
362    Vars.push_back(Variable(Name, NumElements, Data, Flags));
363  }
364
365  template <typename T, typename A>
366  void addScalarizedVariable(const std::string &Name, std::vector<T, A> &Data,
367                             std::size_t NumElements, unsigned Flags = 0) {
368    T *D = Data.empty() ? 0 : &Data[0];
369    addScalarizedVariable(Name, D, NumElements, Flags);
370  }
371
372#ifndef GENERICIO_NO_MPI
373  // Writing
374  void write();
375#endif
376
377  enum MismatchBehavior {
378    MismatchAllowed,
379    MismatchDisallowed,
380    MismatchRedistribute
381  };
382
383  // Reading
384  void openAndReadHeader(MismatchBehavior MB = MismatchDisallowed,
385                         int EffRank = -1, bool CheckPartMap = true);
386
387  int readNRanks();
388  void readDims(int Dims[3]);
389
390  // Note: For partitioned inputs, this returns -1.
391  uint64_t readTotalNumElems();
392
393  void readPhysOrigin(double Origin[3]);
394  void readPhysScale(double Scale[3]);
395
396  void clearVariables() { this->Vars.clear(); };
397
398  int getNumberOfVariables() { return this->Vars.size(); };
399
400  void getVariableInfo(std::vector<VariableInfo> &VI);
401
402  std::size_t readNumElems(int EffRank = -1);
403  void readCoords(int Coords[3], int EffRank = -1);
404  int readGlobalRankNumber(int EffRank = -1);
405
406  void readData(int EffRank = -1, bool PrintStats = true, bool CollStats = true);
407
408  void getSourceRanks(std::vector<int> &SR);
409
410  void close() {
411    FH.close();
412  }
413
414  void setPartition(int P) {
415    Partition = P;
416  }
417
418  static void setDefaultFileIOType(unsigned FIOT) {
419    DefaultFileIOType = FIOT;
420  }
421
422  static void setDefaultPartition(int P) {
423    DefaultPartition = P;
424  }
425
426  static void setNaturalDefaultPartition();
427
428  static void setDefaultShouldCompress(bool C) {
429    DefaultShouldCompress = C;
430  }
431
432#ifndef GENERICIO_NO_MPI
433  static void setCollectiveMPIIOThreshold(std::size_t T) {
434#ifndef GENERICIO_NO_NEVER_USE_COLLECTIVE_IO
435    CollectiveMPIIOThreshold = T;
436#endif
437  }
438#endif
439
440private:
441  // Implementation functions templated on the Endianness of the underlying
442  // data.
443
444#ifndef GENERICIO_NO_MPI
445  template <bool IsBigEndian>
446  void write();
447#endif
448
449  template <bool IsBigEndian>
450  void readHeaderLeader(void *GHPtr, MismatchBehavior MB, int Rank, int NRanks,
451                        int SplitNRanks, std::string &LocalFileName,
452                        uint64_t &HeaderSize, std::vector<char> &Header);
453
454  template <bool IsBigEndian>
455  int readNRanks();
456
457  template <bool IsBigEndian>
458  void readDims(int Dims[3]);
459
460  template <bool IsBigEndian>
461  uint64_t readTotalNumElems();
462
463  template <bool IsBigEndian>
464  void readPhysOrigin(double Origin[3]);
465
466  template <bool IsBigEndian>
467  void readPhysScale(double Scale[3]);
468
469  template <bool IsBigEndian>
470  int readGlobalRankNumber(int EffRank);
471
472  template <bool IsBigEndian>
473  size_t readNumElems(int EffRank);
474
475  template <bool IsBigEndian>
476  void readCoords(int Coords[3], int EffRank);
477
478  void readData(int EffRank, size_t RowOffset, int Rank,
479                uint64_t &TotalReadSize, int NErrs[3]);
480
481  template <bool IsBigEndian>
482  void readData(int EffRank, size_t RowOffset,
483                int Rank, uint64_t &TotalReadSize, int NErrs[3]);
484
485  template <bool IsBigEndian>
486  void getVariableInfo(std::vector<VariableInfo> &VI);
487
488protected:
489  std::vector<Variable> Vars;
490  std::size_t NElems;
491
492  double PhysOrigin[3], PhysScale[3];
493
494  unsigned FileIOType;
495  int Partition;
496#ifndef GENERICIO_NO_MPI
497  MPI_Comm Comm;
498#endif
499  std::string FileName;
500
501  static unsigned DefaultFileIOType;
502  static int DefaultPartition;
503  static bool DefaultShouldCompress;
504
505#ifndef GENERICIO_NO_MPI
506  static std::size_t CollectiveMPIIOThreshold;
507#endif
508
509  // When redistributing, the rank blocks which this process should read.
510  bool Redistributing, DisableCollErrChecking;
511  std::vector<int> SourceRanks;
512
513  std::vector<int> RankMap;
514#ifndef GENERICIO_NO_MPI
515  MPI_Comm SplitComm;
516#endif
517  std::string OpenFileName;
518
519  // This reference counting mechanism allows the the GenericIO class
520  // to be used in a cursor mode. To do this, make a copy of the class
521  // after reading the header but prior to adding the variables.
522  struct FHManager {
523    FHManager() : CountedFH(0) {
524      allocate();
525    }
526
527    FHManager(const FHManager& F) {
528      CountedFH = F.CountedFH;
529      CountedFH->Cnt += 1;
530    }
531
532    ~FHManager() {
533      close();
534    }
535
536    GenericFileIO *&get() {
537      if (!CountedFH)
538        allocate();
539
540      return CountedFH->GFIO;
541    }
542
543    std::vector<char> &getHeaderCache() {
544      if (!CountedFH)
545        allocate();
546
547      return CountedFH->HeaderCache;
548    }
549
550    bool isBigEndian() {
551      return CountedFH ? CountedFH->IsBigEndian : false;
552    }
553
554    void setIsBigEndian(bool isBE) {
555      CountedFH->IsBigEndian = isBE;
556    }
557
558    void allocate() {
559      close();
560      CountedFH = new FHWCnt;
561    };
562
563    void close() {
564      if (CountedFH && CountedFH->Cnt == 1)
565        delete CountedFH;
566      else if (CountedFH)
567        CountedFH->Cnt -= 1;
568
569      CountedFH = 0;
570    }
571
572    struct FHWCnt {
573      FHWCnt() : GFIO(0), Cnt(1), IsBigEndian(false) {}
574
575      ~FHWCnt() {
576        close();
577      }
578
579protected:
580      void close() {
581        delete GFIO;
582        GFIO = 0;
583      }
584
585public:
586      GenericFileIO *GFIO;
587      size_t Cnt;
588
589      // Used for reading
590      std::vector<char> HeaderCache;
591      bool IsBigEndian;
592    };
593
594    FHWCnt *CountedFH;
595  } FH;
596};
597
598} /* END namespace cosmotk */
599#endif // GENERICIO_H
600
Note: See TracBrowser for help on using the repository browser.