displacementTools.hpp

Go to the documentation of this file.

/*
 * MeDiPack, a Message Differentiation Package
 *
 * Copyright (C) 2015-2023 Chair for Scientific Computing (SciComp), University of Kaiserslautern-Landau
 * Homepage: http://www.scicomp.uni-kl.de
 * Contact:  Prof. Nicolas R. Gauger (codi@scicomp.uni-kl.de)
 *
 * Lead developers: Max Sagebaum (SciComp, University of Kaiserslautern-Landau)
 *
 * This file is part of MeDiPack (http://www.scicomp.uni-kl.de/software/codi).
 *
 * MeDiPack is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation, either
 * version 3 of the License, or (at your option) any later version.
 *
 * MeDiPack 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 Lesser General Public License for more details.
 * You should have received a copy of the GNU
 * Lesser General Public License along with MeDiPack.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Authors: Max Sagebaum, Tim Albring (SciComp, University of Kaiserslautern-Landau)
 */
 
#pragma once
 
 
#include "macros.h"
 
namespace medi {
 
  struct LinearDisplacements {
 
      int* displs;
 
      int* counts;
 
      inline LinearDisplacements(int commSize, int length) {
        counts = new int[commSize];
        displs = new int[commSize];
        for(int i = 0; i < commSize; ++i) {
          counts[i] = length;
          displs[i] = i * length;
        }
      }
 
      inline ~LinearDisplacements() {
        delete [] displs;
        delete [] counts;
      }
 
      static inline void deleteFunc(void* d) {
        LinearDisplacements* data = reinterpret_cast<LinearDisplacements*>(d);
 
        delete data;
      }
  };
 
  inline int computeDisplacementsTotalSize(const int* counts, int ranks) {
    int totalSize = 0;
    for(int i = 0; i < ranks; ++i) {
      totalSize += counts[i];
    }
 
    return totalSize;
  }
 
  inline int* createLinearDisplacements(const int* counts, int ranks) {
    int* displs = new int[ranks];
 
    displs[0] = 0;
    for(int i = 1; i < ranks; ++i) {
      displs[i] = counts[i - 1] +  displs[i - 1];
    }
 
    return displs;
  }
 
  inline void createLinearDisplacementsAndCount(int* &countsOut, int* &displsOut, const int* counts, int ranks, int scale) {
    displsOut = new int[ranks];
    countsOut = new int[ranks];
 
    countsOut[0] = counts[0] * scale;
    displsOut[0] = 0;
    for(int i = 1; i < ranks; ++i) {
      countsOut[i] = counts[i] * scale;
      displsOut[i] = countsOut[i - 1] +  displsOut[i - 1];
    }
  }
 
  template<typename Datatype>
  inline void createLinearIndexCounts(int* &linearCounts, const int* counts, const int* displs, int ranks, Datatype* type) {
    linearCounts = new int[ranks];
 
    linearCounts[0] = type->computeActiveElements(displs[0] + counts[0]);
    int lastSum = linearCounts[0];
    for(int i = 1; i < ranks; ++i) {
      int curSum = type->computeActiveElements(displs[i] + counts[i]);
      linearCounts[i] =  curSum - lastSum;
      lastSum = curSum;
    }
  }
}