HDFDatabaseMPIO.h

 
// Description: The concrete database implementation using HDF5.
 
#ifndef included_HDFDatabaseMPI_h
#define included_HDFDatabaseMPI_h
 
#include "HDFDatabase.h"
 
namespace CAROM {
 
class HDFDatabaseMPIO : public HDFDatabase
{
public:
    HDFDatabaseMPIO();
 
    virtual
    ~HDFDatabaseMPIO() {}
 
#if HDF5_IS_PARALLEL
    bool
    create(
        const std::string& file_name,
        const MPI_Comm comm=MPI_COMM_WORLD) override;
 
    bool
    open(
        const std::string& file_name,
        const std::string& type,
        const MPI_Comm comm=MPI_COMM_WORLD) override;
 
    void
    putIntegerArray(
        const std::string& key,
        const int* const data,
        int nelements,
        const bool distributed=false) override
    {
        if ((!distributed) && (d_rank != 0))
            nelements = 0;
        putIntegerArray_parallel(key, data, nelements);
    }
 
    void
    putDoubleArray(
        const std::string& key,
        const double* const data,
        int nelements,
        const bool distributed=false) override
    {
        if ((!distributed) && (d_rank != 0))
            nelements = 0;
        putDoubleArray_parallel(key, data, nelements);
    }
 
    void
    getIntegerArray(
        const std::string& key,
        int* data,
        int nelements,
        const bool distributed=false) override
    {
        if (distributed)
        {
            getIntegerArray_parallel(key, data, nelements);
            return;
        }
 
        int read_size = (d_rank == 0) ? nelements : 0;
        getIntegerArray_parallel(key, data, read_size);
 
        CAROM_VERIFY(d_comm != MPI_COMM_NULL);
        MPI_Bcast(data, nelements, MPI_INT, 0, d_comm);
    }
 
    void
    getDoubleArray(
        const std::string& key,
        double* data,
        int nelements,
        const bool distributed=false) override
    {
        if (distributed)
        {
            getDoubleArray_parallel(key, data, nelements);
            return;
        }
 
        int read_size = (d_rank == 0) ? nelements : 0;
        getDoubleArray_parallel(key, data, read_size);
 
        CAROM_VERIFY(d_comm != MPI_COMM_NULL);
        MPI_Bcast(data, nelements, MPI_DOUBLE, 0, d_comm);
    }
 
    void
    getDoubleArray(
        const std::string& key,
        double* data,
        int nelements,
        const std::vector<int>& idx,
        const bool distributed=false) override
    {
        if (distributed)
        {
            getDoubleArray_parallel(key, data, nelements, idx);
            return;
        }
 
        int read_size = (d_rank == 0) ? nelements : 0;
        getDoubleArray_parallel(key, data, read_size, idx);
 
        CAROM_VERIFY(d_comm != MPI_COMM_NULL);
        MPI_Bcast(data, nelements, MPI_DOUBLE, 0, d_comm);
    }
 
    void
    getDoubleArray(
        const std::string& key,
        double* data,
        int nelements,
        int offset,
        int block_size,
        int stride,
        const bool distributed=false) override
    {
        if (distributed)
        {
            getDoubleArray_parallel(key, data, nelements, offset, block_size, stride);
            return;
        }
 
        int read_size = (d_rank == 0) ? nelements : 0;
        getDoubleArray_parallel(key, data, read_size, offset, block_size, stride);
 
        CAROM_VERIFY(d_comm != MPI_COMM_NULL);
        MPI_Bcast(data, nelements, MPI_DOUBLE, 0, d_comm);
    }
 
    void
    writeAttribute(
        int type_key,
        hid_t dataset_id) override;
 
private:
    MPI_Comm d_comm;
    int d_rank;
 
    virtual
    void
    putIntegerArray_parallel(
        const std::string& key,
        const int* const data,
        int nelem_local);
 
    virtual
    void
    putDoubleArray_parallel(
        const std::string& key,
        const double* const data,
        int nelem_local);
 
    virtual
    void
    getIntegerArray_parallel(
        const std::string& key,
        int* data,
        int nelem_local);
 
    virtual
    void
    getDoubleArray_parallel(
        const std::string& key,
        double* data,
        int nelem_local);
 
    virtual
    void
    getDoubleArray_parallel(
        const std::string& key,
        double* data,
        int nelem_local,
        const std::vector<int>& idx_local);
 
    virtual
    void
    getDoubleArray_parallel(
        const std::string& key,
        double* data,
        int nelem_local,
        int block_offset_global,
        int block_size_global,
        int stride_global);
#endif
};
 
}
 
#endif