ParallelDataCollector.hpp

#ifndef PARALLELDATACOLLECTOR_HPP
#define PARALLELDATACOLLECTOR_HPP

#include <mpi.h>
#include <sstream>
#include <string>
#include <iostream>
#include <set>
#include <hdf5.h>

#include "splash/IParallelDataCollector.hpp"

#include "splash/DCException.hpp"
#include "splash/sdc_defines.hpp"
#include "splash/pdc_defines.hpp"
#include "splash/core/HandleMgr.hpp"

namespace splash
{

    class DCGroup;

    class ParallelDataCollector : public IParallelDataCollector
    {
    private:
        void setFileAccessParams(hid_t& fileAccProperties);

        static std::string getExceptionString(std::string func, std::string msg,
                const char *info = NULL);

        static void indexToPos(int index, Dimensions mpiSize, Dimensions &mpiPos);

        static void listFilesInDir(const std::string baseFilename, std::set<int32_t> &ids)
        throw (DCException);
        hid_t openGroup(DCGroup& group, int32_t id, const char* dataName) throw (DCException);
    protected:

        typedef struct
        {
            // internal MPI structures
            MPI_Comm mpiComm;
            MPI_Info mpiInfo;
            int mpiRank;
            int mpiSize;
            Dimensions mpiPos;
            Dimensions mpiTopology;
            // enable data compression
            bool enableCompression;
            // id for maximum accessed iteration
            int32_t maxID;
        } Options;

        enum FileStatusType
        {
            FST_CLOSED, FST_WRITING, FST_READING, FST_CREATING
        };

        Options options;

        // internal hdf5 file handles
        HandleMgr handles;

        // property list for hdf5 file access
        hid_t fileAccProperties;

        // current file access type
        FileStatusType fileStatus;

        // filename passed to PDC
        std::string baseFilename;

        static void writeHeader(hid_t fHandle, uint32_t id,
                bool enableCompression, Dimensions mpiTopology) throw (DCException);

        static void fileCreateCallback(H5Handle handle, uint32_t index,
                void *userData) throw (DCException);

        static void fileOpenCallback(H5Handle handle, uint32_t index,
                void *userData) throw (DCException);

        void openCreate(const char *filename,
                FileCreationAttr &attr) throw (DCException);

        void openRead(const char *filename,
                FileCreationAttr &attr) throw (DCException);

        void openWrite(const char *filename,
                FileCreationAttr &attr) throw (DCException);

        void readCompleteDataSet(H5Handle h5File,
                int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                const Dimensions srcOffset,
                Dimensions &sizeRead,
                uint32_t& srcRank,
                void* dst) throw (DCException);

        void readDataSet(H5Handle h5File,
                int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                const Dimensions srcSize,
                const Dimensions srcOffset,
                Dimensions &sizeRead,
                uint32_t& srcRank,
                void* dst) throw (DCException);

        void writeDataSet(
                H5Handle group,
                const Dimensions globalSize,
                const Dimensions globalOffset,
                const CollectionType& datatype,
                uint32_t rank,
                const Selection srcSelect,
                const char* name,
                const void* data) throw (DCException);

        void gatherMPIWrites(int rank, const Dimensions localSize,
                Dimensions &globalSize, Dimensions &globalOffset) throw (DCException);

        size_t getNDims(H5Handle h5File,
                int32_t id,
                const char* name);

        void reserveInternal(int32_t id,
                const Dimensions globalSize,
                uint32_t rank,
                const CollectionType& type,
                const char* name) throw (DCException);

    public:
        ParallelDataCollector(MPI_Comm comm, MPI_Info info, const Dimensions topology,
                uint32_t maxFileHandles);

        virtual ~ParallelDataCollector();

        void open(const char *filename,
                FileCreationAttr& attr) throw (DCException);

        void close();

        int32_t getMaxID();

        void getMPISize(Dimensions& mpiSize);

        void getEntryIDs(int32_t *ids, size_t *count) throw (DCException);

        void getEntriesForID(int32_t id, DCEntry *entries, size_t *count) throw (DCException);

        void write(int32_t id,
                const CollectionType& type,
                uint32_t rank,
                const Selection select,
                const char* name,
                const void* buf) throw (DCException);

        void write(int32_t id,
                const Dimensions globalSize,
                const Dimensions globalOffset,
                const CollectionType& type,
                uint32_t rank,
                const Selection select,
                const char* name,
                const void* buf);

        void reserve(int32_t id,
                const Dimensions globalSize,
                uint32_t rank,
                const CollectionType& type,
                const char* name) throw (DCException);

        void reserve(int32_t id,
                const Dimensions size,
                Dimensions *globalSize,
                Dimensions *globalOffset,
                uint32_t rank,
                const CollectionType& type,
                const char* name) throw (DCException);

        void append(int32_t id,
                const Dimensions size,
                uint32_t rank,
                const Dimensions globalOffset,
                const char *name,
                const void *buf);

        void remove(int32_t id) throw (DCException);

        void remove(int32_t id,
                const char *name) throw (DCException);

        void createReference(int32_t srcID,
                const char *srcName,
                int32_t dstID,
                const char *dstName) throw (DCException);

        AttributeInfo readGlobalAttributeInfo(int32_t id,
                const char* name,
                Dimensions *mpiPosition = NULL) throw (DCException);

        SPLASH_DEPRECATED("Use safer readGlobalAttributeInfo")
        void readGlobalAttribute(int32_t id,
                const char* name,
                void* buf) throw (DCException);

        void writeGlobalAttribute(int32_t id,
                const CollectionType& type,
                const char *name,
                const void* buf) throw (DCException);

        void writeGlobalAttribute(int32_t id,
                const CollectionType& type,
                const char *name,
                uint32_t ndims,
                const Dimensions dims,
                const void* buf) throw (DCException);

        AttributeInfo readAttributeInfo(int32_t id,
                const char *dataName,
                const char *attrName,
                Dimensions *mpiPosition = NULL) throw (DCException);

        SPLASH_DEPRECATED("Use safer readAttributeInfo")
        void readAttribute(int32_t id,
                const char *dataName,
                const char *attrName,
                void *buf,
                Dimensions *mpiPosition = NULL) throw (DCException);

        void writeAttribute(int32_t id,
                const CollectionType& type,
                const char *dataName,
                const char *attrName,
                const void *buf) throw (DCException);

        void writeAttribute(int32_t id,
                const CollectionType& type,
                const char *dataName,
                const char *attrName,
                uint32_t ndims,
                const Dimensions dims,
                const void *buf) throw (DCException);

        void read(int32_t id,
                const char* name,
                Dimensions &sizeRead,
                void* buf) throw (DCException);

        void read(int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                Dimensions &sizeRead,
                void* buf) throw (DCException);

        CollectionType* readMeta(int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                Dimensions &sizeRead) throw (DCException);

        void read(int32_t id,
                const Dimensions localSize,
                const Dimensions globalOffset,
                const char* name,
                Dimensions &sizeRead,
                void* buf) throw (DCException);

        void read(int32_t id,
                const Dimensions localSize,
                const Dimensions globalOffset,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                Dimensions &sizeRead,
                void* buf) throw (DCException);

        void finalize(void);

    private:

        /* Invalid methods from DataCollector. Do NOT call! */

        SPLASH_DEPRECATED("Use safer readGlobalAttributeInfo")
        void readGlobalAttribute(const char*,
                void*,
                Dimensions*) throw (DCException);

        void writeGlobalAttribute(const CollectionType& /*type*/,
                const char* /*name*/,
                const void* /*data*/) throw (DCException);

        void writeGlobalAttribute(const CollectionType& /*type*/,
                const char* /*name*/,
                uint32_t /*ndims*/,
                const Dimensions /*dims*/,
                const void* /*data*/) throw (DCException);

        void append(int32_t /*id*/,
                const CollectionType& /*type*/,
                size_t /*count*/,
                const char* /*name*/,
                const void* /*data*/) throw (DCException);

        void append(int32_t /*id*/,
                const CollectionType& /*type*/,
                size_t /*count*/,
                size_t /*offset*/,
                size_t /*stride*/,
                const char* /*name*/,
                const void* /*data*/) throw (DCException);

        void createReference(int32_t /*srcID*/,
                const char* /*srcName*/,
                int32_t /*dstID*/,
                const char* /*dstName*/,
                Dimensions /*count*/,
                Dimensions /*offset*/,
                Dimensions /*stride*/) throw (DCException);

        /* End invalid methods */

        CollectionType* readDataSetMeta(H5Handle h5File,
                int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                const Dimensions srcOffset,
                Dimensions &sizeRead,
                uint32_t& srcDims)
         throw (DCException);
    };

}

#endif /* PARALLELDATACOLLECTOR_HPP */