include/twod/uniform_2d_impl.hpp

Go to the documentation of this file.

// This file is part of SPart, Spatially Located Workload Partitioner.

// Copyright (C) 2011, The Ohio State University
// SPart developed by Erdeniz O. Bas, Erik Saule and Umit V. Catalyurek 

// For questions, comments, suggestions, bugs please send e-mail to: 
// Umit V. Catalyurek   catalyurek.1@osu.edu

// SPart is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free
// Software Foundation; either version 2 or (at your option) any later
// version.

// SPart 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 General Public License
// for more details.

// You should have received a copy of the GNU General Public License
// along with SPart; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

// As a special exception, if other files instantiate templates or use
// macros or inline functions from this file, or you compile this file
// and link it with other works to produce a work based on this file,
// this file does not by itself cause the resulting work to be covered by
// the GNU General Public License. However the source code for this file
// must still be made available in accordance with section (3) of the GNU
// General Public License.

// This exception does not invalidate any other reasons why a work based
// on this file might be covered by the GNU General Public License.

// The full text of the GPL license version 2 is available in "gpl.txt".

#include <twod/uniform_2d.hpp>
#include <math.h>

template <typename T, typename Pr>
T twod::Uniform<T, Pr>::part(int procCount, const Pr& prefixSumArray, util::RectList<T,Pr> &parts)
{
  using namespace util;
  rectangle r;
  int x_parts;
  if (P==0)
    {
      x_parts = intfactor(procCount);
    }
  else
    {
      x_parts = P;
    }


  int y_parts = procCount / x_parts;

  assert (x_parts>0); 
  assert (x_parts<=procCount); 
  assert (y_parts>0); 
  assert (y_parts<=procCount); 

  double len_x_part = ((double)(prefixSumArray.prefixsizeX() - 1)) / x_parts;
  double len_y_part = ((double)(prefixSumArray.prefixsizeY() - 1)) / y_parts;
  int i,j;

  int xl = 1;
  int xh;
  int yl;
  int yh;

  for(i=1;i<=x_parts;i++)
    {
      if (i == x_parts) //to avoid rounding issues
        xh = prefixSumArray.prefixsizeX() - 1;
      else      
        xh = (int) round(i*len_x_part);
      yl = 1;
      for(j=1;j<=y_parts;j++)
        {
          if (j == y_parts) //to avoid rounding issues
            yh = prefixSumArray.prefixsizeY() - 1;
          else
            yh = (int) round(j*len_y_part);
          
          parts.add_rect( rectangle(xl,xh,yl,yh) );
          yl = yh + 1;
        }
      xl = xh + 1;
    }
  
  return parts.get_maximum_load();
}