|| || || || || || || ||

---

PxReadWriteRaw.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2003-2004, University of Amsterdam, The Netherlands.
 *  All rights reserved.
 *
 *  Author(s):
 *  Dennis Koelma <koelma@wins.uva.nl>
 *  Frank Seinstra <fjseins@wins.uva.nl>
 */

#ifndef __PxReadWriteRaw_h_
#define __PxReadWriteRaw_h_


#include <vector>
#include "Basis/String.h"
#include "Core/Array/Element/TypeString.h"
#include "Basis/NativeTypeRead.h"
#include "Basis/NativeTypeFormats.h"
#include "Core/Array/ArrayType.h"
#include "Core/Array/Pattern/ArrayFunc.h"

#include "Core/Array/Pattern/PxSystem.h"
#include "mpi.h"

namespace Impala
{
namespace Core
{
namespace Array
{
namespace Pattern
{


template<class ArrayT>
inline ArrayT*
PxReadRaw(ArrayT* dst, std::string fileName)
{
    typedef typename ArrayT::StorType StorT;

    FILE* fp;

    if (PxMyCPU() == PxRootCPU()) {
        if (! (fp = fopen(fileName.c_str(), "r"))) {
            PX_COUT << "PxReadRaw: unable to open file " << fileName
                    << PX_ENDL;
            PxAbortSystem();
        }
    }

    std::string typeStr = Element::TypeString<StorT>(0);
    std::string formatStr = std::string("version: 1, binary: %d, type: ")
        + typeStr
        + std::string(", elemSize: %d, width: %d, height: %d, nr: %d");
    int binary;
    int elemSize;
    int width;
    int height;
    int nrA;
    char buf[200];

    if (PxMyCPU() == PxRootCPU()) {
        fgets(buf, 200, fp);
        int res = sscanf(buf, formatStr.c_str(),
                        &binary, &elemSize, &width, &height, &nrA);
        if ((res != 5) ||
            (elemSize != ArrayT::ElemSize()) || (nrA != 1)) {
            fclose(fp);
            PX_COUT << "Header of " << fileName << " is not compatible"
                    << PX_ENDL;
            PxAbortSystem();
        }
    }
    int blockSize = width*height*elemSize;

    int sizes[2];
    sizes[0] = width;
    sizes[1] = height;
    MPI_Bcast(sizes, 2, MPI_INT, PxRootCPU(), MPI_COMM_WORLD);

    if (dst == 0)
        dst = ArrayCreate<ArrayT>(sizes[0], sizes[1]);

    if (PxMyCPU() == PxRootCPU()) {
        StorT* dstPtr = ArrayCPB(dst, 0, 0);
        if (binary) {
            fclose(fp);
            fp = fopen(fileName.c_str(), "rb");
            fread(buf, sizeof(char), 200, fp);
            for (int n=0 ; n<nrA ; n++) {
                fread(dstPtr, sizeof(StorT), blockSize, fp);
                dstPtr += blockSize;
            }
        } else {
            for (int n=0 ; n<nrA ; n++) {
                for(int i=0 ; i<height ; i++) {
                    for(int j=0 ; j<width ; j++) {
                        for (int k=0 ; k<elemSize ; k++) {
                            NativeTypeRead(fp, dstPtr);
                            dstPtr++;
                        }
                    }
                }
            }
        }
        fclose(fp);
    }
    // NOTE: Here we haven't used PxInitDistribution yet!!!!
    PxBcastArray(dst, PxRootCPU());
    return dst;
}


template<class ArrayT>
inline void
PxWriteRaw(ArrayT* src, std::string fileName, bool binary)
{
    PxArrayForceNonDistributed(src);

    if (PxMyCPU() == PxRootCPU()) {
        typedef typename ArrayT::StorType StorT;

        std::string typeStr = Element::TypeString<StorT>(0);
        std::string formatStr = std::string("version: 1, binary: %d, type: ")
            + typeStr + std::string(", elemSize: %d, width: %d, height: %d, nr: %d");
        int width = ArrayCW(src);
        int height = ArrayCH(src);
        int elemSize = ArrayT::ElemSize();
        int nrA = 1;
        char buf[200];
        sprintf(buf, formatStr.c_str(), binary, elemSize, width, height, nrA);

        FILE* fp;
        if (binary) {   // write to binary file
            fp = fopen(fileName.c_str(), "wb");
            fwrite(buf, sizeof(char), 200, fp);
            for (int y=0 ; y<height ; y++) {
                StorT* srcPtr = ArrayCPB(src, 0, y);
                fwrite(srcPtr, sizeof(StorT), width*elemSize, fp);
            }
        } else {        // write to text file
            fp = fopen(fileName.c_str(), "w") ;
            fprintf(fp, "%s\n", buf);
            std::string fs = NativeTypeFormat<StorT>(0) + std::string(" ");
            for (int n=0 ; n<nrA ; n++) {
                for(int i=0 ; i<height ; i++) {
                    StorT* srcPtr = ArrayCPB(src, 0, i);
                    for(int j=0 ; j<width ; j++) {
                        for (int k=0 ; k<elemSize ; k++) {
                            fprintf(fp, fs.c_str(), *srcPtr++);
                        }
                    }
                    fprintf(fp, "\n");
                }
            }
        }
        fclose(fp);
    }
}


} // namespace Pattern
} // namespace Array
} // namespace Core
} // namespace Impala

#endif /* __PxReadWriteRaw_h_ */

---