mpi.h

/* -*- c++ -*- */
/*
 * Expresso, a C++ Array template class library
 * Copyright (C) 1998,2004 Oskar Enoksson (enok@lysator.liu.se)
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA  02111-1307, USA.
 */
#ifndef EXPRESSO_MPI_HDR
#define EXPRESSO_MPI_HDR

#ifdef USE_MPIPP
#include <mpi++.h>
#endif
#ifdef USE_MPI
#include <mpi.h>
#endif


namespace esso {


#ifdef USE_MPIPP

  template<class T>
  struct MPIPPType;

  template<>
  struct MPIPPType<char> { 
    inline static const MPI::Datatype & Get() { return MPI::CHAR; } };
  template<>
  struct MPIPPType<unsigned char> { 
    inline static const MPI::Datatype & Get() { return MPI::UNSIGNED_CHAR; } };
  template<>
  struct MPIPPType<short> { 
    inline static const MPI::Datatype & Get() { return MPI::SHORT; } };
  template<>
  struct MPIPPType<unsigned short> { 
    inline static const MPI::Datatype & Get() { return MPI::UNSIGNED_SHORT; } };
  template<>
  struct MPIPPType<int> { 
    inline static const MPI::Datatype & Get() { return MPI::INT; } };
  template<>
  struct MPIPPType<unsigned> { 
    inline static const MPI::Datatype & Get() { return MPI::UNSIGNED; } };
  template<>
  struct MPIPPType<long> { 
    inline static const MPI::Datatype & Get() { return MPI::LONG; } };
  template<>
  struct MPIPPType<unsigned long> { 
    inline static const MPI::Datatype & Get() { return MPI::UNSIGNED_LONG; } };
  template<>
  struct MPIPPType<float> { 
    inline static const MPI::Datatype & Get() { return MPI::FLOAT; } };
  template<>
  struct MPIPPType<double> { 
    inline static const MPI::Datatype & Get() { return MPI::DOUBLE; } };

  template<int N, class Type>
  inline MPI::Datatype
  CreateMPIPPArray(const Array<N,Type> &array){
    if(array.IsNull())
      return MPI::Datatype();
    typedef typename Array<N,Type>::T T;
    MPI::Datatype type = MPIPPType<T>::Get();

    for(int n=0; n<N; n++) {
      MPI::Datatype oldtype=type;
      type = oldtype.Create_hvector(array.Len(n),1,
                                    array.Stride(n)*sizeof(T));
      if(n>0)
        oldtype.Free();
    }
    return type;
  }
#endif
#ifdef USE_MPI

  template<class T>
  struct MPIType;

  template<>
  struct MPIType<char> { 
    inline static MPI_Datatype Get() { return MPI_CHAR; } };
  template<>
  struct MPIType<unsigned char> { 
    inline static MPI_Datatype Get() { return MPI_UNSIGNED_CHAR; } };
  template<>
  struct MPIType<short> { 
    inline static MPI_Datatype Get() { return MPI_SHORT; } };
  template<>
  struct MPIType<unsigned short> { 
    inline static MPI_Datatype Get() { return MPI_UNSIGNED_SHORT; } };
  template<>
  struct MPIType<int> { 
    inline static MPI_Datatype Get() { return MPI_INT; } };
  template<>
  struct MPIType<unsigned> { 
    inline static MPI_Datatype Get() { return MPI_UNSIGNED; } };
  template<>
  struct MPIType<long> { 
    inline static MPI_Datatype Get() { return MPI_LONG; } };
  template<>
  struct MPIType<unsigned long> { 
    inline static MPI_Datatype Get() { return MPI_UNSIGNED_LONG; } };
  template<>
  struct MPIType<float> { 
    inline static MPI_Datatype Get() { return MPI_FLOAT; } };
  template<>
  struct MPIType<double> { 
    inline static MPI_Datatype Get() { return MPI_DOUBLE; } };

  template<int N, class Type>
  inline MPI_Datatype
  CreateMPIArray(const Array<N,Type> &array){
    if(array.IsNull())
      return MPI_DATATYPE_NULL;
    typedef typename Array<N,Type>::T T;
    MPI_Datatype type = MPIType<T>::Get();

    for(int n=0; n<N; n++) {
      MPI_Datatype oldtype = type;
      MPI_Type_hvector(array.Len(n), 1, array.Stride(n)*sizeof(T), 
                       oldtype, &type);
      if(n>0)
        MPI_Type_free(&oldtype);
    }
    return type;
  }
#endif

}

#endif

---