file.h

Go to the documentation of this file.

template<class _InIt> inline
void binary_read(_InIt _First, _InIt _Last, const string _Filename, const int _Seek)
{
        ifstream is(_Filename.c_str(), ios::binary);
        is.seekg(_Seek * sizeof(*_First));
        is.read((char*)&*_First, streamsize(_Last - _First) * sizeof(*_First));
        is.close();
}

template<class _InIt> inline
void binary_write(_InIt _First, _InIt _Last, const string _Filename)
{
        ofstream os(_Filename.c_str(), ios::binary);
        os.write((char*)&*_First, streamsize(_Last - _First) * sizeof(*_First));
        os.close();
}

template<class T>
void read_header(const string &_root, vector<T> &_hdr)
{
        _hdr.assign(8, 0);
        binary_read(_hdr.begin(), _hdr.end(), _root + "Header.bin", 0);

        T magic = _hdr[0];
        T version = _hdr[1];
        T gnumelem = _hdr[2];
        T elemsize = _hdr[3];
        T gnumnode = _hdr[4];
        T nodesize = _hdr[5];
        T gnumdir = _hdr[6];
        T dirsize = _hdr[7];

        int rank;
        network::rank(rank);
        if(rank == 0)
        {
                cout << "Magic: " << magic << " Version: " << version << endl;
                cout << "Elements: " << gnumelem << " Size: " << elemsize << endl;
                cout << "Nodes: " << gnumnode << " Size: " << nodesize << endl;
                cout << "Dirichlet: " << gnumdir << " Size: " << dirsize << endl;
        }
}

template<class T>
void read_partition(const string &_root, const vector<T> &_hdr, vector<T> &_par)
{
        T gnumelem = _hdr[2];

        int size, rank;
        network::size(size);
        network::rank(rank);
        int poselem = (rank * gnumelem)/size;
        int numelem = (rank * gnumelem + gnumelem)/size - poselem;

        _par.assign(numelem, 0);
        stringstream s;
        s << _root << "Partition" << size << ".bin";
        binary_read(_par.begin(), _par.end(), s.str(), poselem);
}

template<class T>
void read_connection(const string &_root, const vector<T> &_hdr, const vector<T> &_par, vector<T> &_con)
{
        T gnumelem = _hdr[2];
        T elemsize = _hdr[3];

        int size, rank;
        network::size(size);
        network::rank(rank);
        int poselem = (rank * gnumelem)/size;
        int numelem = (rank * gnumelem + gnumelem)/size - poselem;
        vector<T> con(numelem * elemsize);
        binary_read(con.begin(), con.end(), _root + "Connection.bin", poselem * elemsize);

        vector<int> slen(size);
        vector<int> soff(size);
        vector<T> scon(numelem * elemsize);
        bucket_sort_count(_par, slen);
        bucket_sort_offset(slen, soff);
        bucket_sort_copy(_par, con, scon, soff, elemsize);

        vector<int> rlen(size);
        vector<int> roff(size);
        network::alltoall(&slen[0], sizeof(int), &rlen[0], sizeof(int));
        bucket_sort_offset(rlen, roff);
        int rnumelem = bucket_sort_size(rlen);
        _con.assign(rnumelem * elemsize, 0);

        for(int i = 0; i < (int)slen.size(); i++) slen[i] *= elemsize * sizeof(T), soff[i] *= elemsize * sizeof(T);
        for(int i = 0; i < (int)slen.size(); i++) rlen[i] *= elemsize * sizeof(T), roff[i] *= elemsize * sizeof(T);
        network::alltoallv(&scon[0], &slen[0], &soff[0], &_con[0], &rlen[0], &roff[0]);
}

template<class T, class S>
void read_element(const string &_root, const vector<T> &_hdr, const vector<T> &_par, vector<S> &_ele)
{
        T gnumelem = _hdr[2];
        T elemsize = _hdr[3];

        int size, rank;
        network::size(size);
        network::rank(rank);
        int poselem = (rank * gnumelem)/size;
        int numelem = (rank * gnumelem + gnumelem)/size - poselem;
        vector<S> ele(numelem * elemsize * elemsize);
        binary_read(ele.begin(), ele.end(), _root + "Element.bin", poselem * elemsize * elemsize);

        vector<int> slen(size);
        vector<int> soff(size);
        vector<S> sele(numelem * elemsize * elemsize);
        bucket_sort_count(_par, slen);
        bucket_sort_offset(slen, soff);
        bucket_sort_copy(_par, ele, sele, soff, elemsize * elemsize);

        vector<int> rlen(size);
        vector<int> roff(size);
        network::alltoall(&slen[0], sizeof(int), &rlen[0], sizeof(int));
        bucket_sort_offset(rlen, roff);
        int rnumelem = bucket_sort_size(rlen);
        _ele.assign(rnumelem * elemsize * elemsize, 0.0);

        for(int i = 0; i < (int)slen.size(); i++) slen[i] *= elemsize * elemsize * sizeof(S), soff[i] *= elemsize * elemsize * sizeof(S);
        for(int i = 0; i < (int)slen.size(); i++) rlen[i] *= elemsize * elemsize * sizeof(S), roff[i] *= elemsize * elemsize * sizeof(S);
        network::alltoallv(&sele[0], &slen[0], &soff[0], &_ele[0], &rlen[0], &roff[0]);
}

---