Domi_Utils.hpp

// @HEADER
// ***********************************************************************
//
//     Domi: Multi-dimensional Distributed Linear Algebra Services
//                 Copyright (2014) Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia
// Corporation, the U.S. Government retains certain rights in this
// software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact William F. Spotz (wfspotz@sandia.gov)
//
// ***********************************************************************
// @HEADER

#ifndef DOMI_UTILS_HPP
#define DOMI_UTILS_HPP

// Domi includes
#include "Domi_ConfigDefs.hpp"

// Teuchos includes
#include "Teuchos_Array.hpp"
#include "Teuchos_ArrayView.hpp"
#include "Teuchos_ParameterList.hpp"

#ifdef HAVE_MPI
// MPI include
#include <mpi.h>
#endif

namespace Domi
{



typedef Teuchos::Ordinal size_type;

typedef Ordinal dim_type;

typedef Ordinal difference_type;

typedef Teuchos::Tuple< int, 2 > padding_type;


enum Layout
{
  C_ORDER             = 0,
  FORTRAN_ORDER       = 1,
  ROW_MAJOR           = 0,
  COLUMN_MAJOR        = 1,
  LAST_INDEX_FASTEST  = 0,
  FIRST_INDEX_FASTEST = 1,
  DEFAULT_ORDER       = 1
};



template< class T >
struct remove_const
{
  typedef T type;
};

template< class T >
struct remove_const< const T >
{
  typedef T type;
};


template< class SIZE_TYPE, class DIM_TYPE >
Teuchos::Array< SIZE_TYPE >
computeStrides(const Teuchos::Array< DIM_TYPE > & dimensions,
               const Layout layout)
{
  int n = dimensions.size();
  Teuchos::Array< SIZE_TYPE > strides(n);
  if (n == 0) return strides;

  if (layout == FIRST_INDEX_FASTEST)
  {
    strides[0] = 1;
    for (int axis = 1; axis < n; ++axis)
      strides[axis] = strides[axis-1] * dimensions[axis-1];
  }
  else
  {
    strides[n-1] = 1;
    for (int axis = n-2; axis >= 0; --axis)
      strides[axis] = strides[axis+1] * dimensions[axis+1];
  }
  return strides;
}


template< class SIZE_TYPE, class DIM_TYPE >
Teuchos::Array< SIZE_TYPE >
computeStrides(const Teuchos::ArrayView< DIM_TYPE > & dimensions,
               const Layout layout)
{
  // In the MDArray<T>(const MDArrayView<T> &) constructor, I try to
  // pass the MDArrayView dimensions to computeStrides(), but they
  // come in as ArrayView<const T> (for reasons I can't determine) and
  // cause all sorts of const-correctness problems.  So I copy them
  // into a new Array<T> and pass its reference to the main
  // computeStrides() function.  Fortunately, the array of dimensions
  // is small.
  Teuchos::Array< DIM_TYPE > nonConstDims(0);
  nonConstDims.insert(nonConstDims.begin(),
                      dimensions.begin(),
                      dimensions.end());
  return computeStrides< SIZE_TYPE, DIM_TYPE >(nonConstDims, layout);
}


template< class DIM_TYPE >
size_type computeSize(const Teuchos::ArrayView< DIM_TYPE > & dimensions)
{
  size_type result = 1;
  for (int axis = 0; axis < dimensions.size(); ++axis)
    result *= dimensions[axis];
  return result;
}


template< class DIM_TYPE >
size_type computeSize(const Teuchos::Array< DIM_TYPE > & dimensions)
{
  // In the MDArray<T>(const MDArrayView<T> &) constructor, I try to
  // pass the MDArrayView dimensions to computeSize(), but they come
  // in as ArrayView<const T> (for reasons I can't determine) and
  // cause all sorts of const-correctness problems.  So I copy them
  // into a new Array<T> and pass its view to the main computeSize()
  // function.  Fortunately, the array of dimensions is small.
  Teuchos::Array< DIM_TYPE > nonConstDims(0);
  nonConstDims.insert(nonConstDims.begin(),
                      dimensions.begin(),
                      dimensions.end());
  return computeSize(nonConstDims());
}


template< class SIZE_TYPE, class DIM_TYPE >
SIZE_TYPE computeSize(const Teuchos::ArrayView< DIM_TYPE > & dimensions,
                      const Teuchos::ArrayView< SIZE_TYPE > & strides)
{
  // SIZE_TYPE might be a const type, but we need result to be non-const
  typename remove_const< SIZE_TYPE >::type result = 1;
  for (int axis = 0; axis < dimensions.size(); ++axis)
    result += (dimensions[axis]-1) * strides[axis];
  return result;
}


Teuchos::Array< int >
factor(int n);


int indexOfMax(const Teuchos::ArrayView< const float > & seq);


Teuchos::Array< int >
decomposeProcs(int nprocs,
               const Teuchos::ArrayView< dim_type > & dimensions);


Teuchos::Array< int >
regularizeCommDims(int numProcs,
                   int numDims,
                   const Teuchos::ArrayView< const int > & commDims);


Teuchos::Array< int >
regularizeCommDims(int numProcs,
                   Teuchos::ParameterList & plist);


Teuchos::Array< int >
computeCommIndexes(int rank,
                   const Teuchos::ArrayView< int > & commStrides);


Teuchos::Array< int >
createArrayOfInts(int numDims,
                  const Teuchos::ArrayView< const int > & source);


Teuchos::Array< int >
splitStringOfIntsWithCommas(std::string data);


#ifdef HAVE_MPI

template< class T > MPI_Datatype mpiType();

#endif


#ifdef HAVE_MPI

int mpiOrder(Layout layout);

#endif

}       // End Domi namespace

#endif  // DOMI_MDARRAY_UTILS_HPP