split.cpp File Reference

#include <math.h>
#include "face.h"
#include "makeflo.h"
#include <algorithm>

Include dependency graph for split.cpp:

Go to the source code of this file.

Classes
class	bRec

Functions
int	volume (const block *b)
const char *	splitBlocks (vector< block * > &blocks, int nPieces)

Function Documentation

const char* splitBlocks	(	vector< block * > &	blocks,
		int	nPieces
	)

Definition at line 205 of file split.cpp.

References bRec::less(), parameters, makefloParam::splithalf, and volume().

Referenced by main().

{
        if ((int)blocks.size()>=nPieces)
                return NULL;//Already have enough blocks


//We try to split so that the resulting blocks
// have about the same volume-- distribute pieces
// to blocks by volume
        unsigned int b,nBlocks=blocks.size();
        
        int *nSplit=new int[nBlocks];   

        if (parameters.splithalf == 1) {
                // split every block in half
          for (b=0;b<nBlocks;b++) {
                nSplit[b]=2;
          }
        }
        else {   // regular split
        //Create max-heap of blocks, ordered by output volume
        vector<bRec> heap(nBlocks);
        for (b=0;b<nBlocks;b++) {
                heap[b]=bRec(b,volume(blocks[b]));
                nSplit[b]=1;
        }

        std::make_heap(heap.begin(),heap.end(),bRec::less);
        
        //Allocate remaining output blocks to the most needy
        int nRemaining=nPieces-nBlocks;
        while (nRemaining-->0) {
                std::pop_heap(heap.begin(),heap.end(),bRec::less);
                bRec &r=heap[nBlocks-1];
                r.n=++(nSplit[r.b]);
                std::push_heap(heap.begin(),heap.end(),bRec::less);
        }
        }   // end of parameters.splithalf
        
        //Split the blocks
        vector<block *> split;//Accumulates split blocks
        for (b=0;b<nBlocks;b++) {
                printf("Input block %d splits into %d pieces (%d-%d)\n",
                        b+1,nSplit[b],(int)(1+split.size()),(int)(1+split.size()+nSplit[b]-1));
                blocks[b]->split(nSplit[b],split);
        }
        delete[] nSplit;

//Check the load balance
        double maxVol=-1e100,minVol=1e100,sumVol=0;
        for (b=0;b<split.size();b++) {
                double vol=volume(split[b]);
                sumVol+=vol;
                if (maxVol<vol) maxVol=vol;
                if (minVol>vol) minVol=vol;
        }
        double avgVol=sumVol/split.size();
        printf("Static load balance results:\n"
                "  %.2f blocks per processor, %.0f nodes per block\n"
                "  Heaviest block is %.02f times the average\n"
                "  Lightest block is %.02f times the average\n",
                ((double)split.size())/nPieces,avgVol,
                maxVol/avgVol,minVol/avgVol);
        
//Return split blocks to caller
        blocks=split;
        return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int volume

(

const block *

b

)

Definition at line 181 of file split.cpp.

References block::getDim(), and blockDim::getSize().

Referenced by checkQuality(), Rocsurf::compute_bounded_volumes(), Rocsurf::compute_swept_volumes(), get_face_volume(), lass(), splitBlocks(), and volumehexa().

                           {
        return b->getDim().getSize();
}

Here is the call graph for this function:

Here is the caller graph for this function: