Changeset 127:3e368f5be1d3

Show
Ignore:
Timestamp:
02/26/2012 10:26:34 PM (15 months ago)
Author:
Andreas Schaefer <gentryx@…>
Branch:
default
Message:
Location:
src/parallelization
Files:
22 modified

Legend:

Unmodified
Added
Removed

  • src/parallelization/hiparsimulator.h

    r108 r127  
    1010#include <libgeodecomp/parallelization/distributedsimulator.h> 
    1111#include <libgeodecomp/parallelization/hiparsimulator/partitions/stripingpartition.h> 
    12 #include <libgeodecomp/parallelization/hiparsimulator/partitionmanager.h> 
    1312#include <libgeodecomp/parallelization/hiparsimulator/intersectingregionaccumulator.h> 
    1413#include <libgeodecomp/parallelization/hiparsimulator/vanillaregionaccumulator.h> 
    … …  
    1716#include <libgeodecomp/parallelization/hiparsimulator/updategroup.h> 
    1817         
    19 // fixme: move implementation to hiparsimulator/implementation? 
    20  
    2118namespace LibGeoDecomp { 
    2219namespace HiParSimulator { 
    2320 
    24 enum EventPoint {LOAD_BALANCING=0, OUTPUT=1, SIMULATION_END=2, PAUSE=3}; 
     21enum EventPoint {LOAD_BALANCING, END, PAUSE}; 
    2522typedef SuperSet<EventPoint> EventSet; 
    2623typedef SuperMap<unsigned, EventSet> EventMap; 
    … …  
    3128    case LOAD_BALANCING: 
    3229        return "LOAD_BALANCING"; 
    33     case OUTPUT:  
    34         return "OUTPUT"; 
    35     case SIMULATION_END: 
    36         return "SIMULATION_END"; 
     30    case END: 
     31        return "END"; 
     32    case PAUSE: 
     33        return "PAUSE"; 
    3734    default: 
    3835        return "invalid"; 
    … …  
    4744    typedef typename CELL_TYPE::Topology Topology; 
    4845    typedef DisplacedGrid<CELL_TYPE, Topology> GridType; 
    49     static const int DIMENSIONS = Topology::DIMENSIONS; 
     46    static const int DIM = Topology::DIMENSIONS; 
    5047 
    5148    inline HiParSimulator( 
    5249        Initializer<CELL_TYPE> *_initializer, 
    5350        LoadBalancer *_balancer = 0, 
    54         const unsigned& _outputPeriod = 1,  
    5551        const unsigned& _loadBalancingPeriod = 1, 
    56         // fixme: move ghostZoneWidth to partition manager 
    57         const unsigned &ghostZoneWidth = 1, 
    58         const unsigned& _root = 0, 
    59         // fixme: forward this to regionStepper 
    60         MPI::Comm *communicator = &MPI::COMM_WORLD) :  
     52        const unsigned &_ghostZoneWidth = 1, 
     53        MPI::Comm *_communicator = &MPI::COMM_WORLD) :  
    6154        DistributedSimulator<CELL_TYPE>(_initializer), 
    6255        balancer(_balancer), 
    63         outputPeriod(_outputPeriod * CELL_TYPE::nanoSteps()), 
    6456        loadBalancingPeriod(_loadBalancingPeriod * CELL_TYPE::nanoSteps()), 
    65         root(_root), 
    66         mpiLayer(communicator), 
    67         eventRepetitionHorizon(4) 
    68     { 
    69         resetSimulation(ghostZoneWidth); 
     57        ghostZoneWidth(_ghostZoneWidth), 
     58        communicator(_communicator) 
     59    { 
     60        CoordBox<DIM> box = this->initializer->gridBox(); 
     61        updateGroup.reset(new UpdateGroup<CELL_TYPE, PARTITION>( 
     62                              PARTITION(box.origin, box.dimensions), 
     63                              initialWeights(box.dimensions.prod(), communicator->Get_size()), 
     64                              0, 
     65                              box, 
     66                              ghostZoneWidth, 
     67                              this->initializer, 
     68                              communicator)); 
     69 
     70        // resetSimulation(ghostZoneWidth); 
    7071    }    
    7172 
    … …  
    7374    inline void run() 
    7475    { 
    75         unsigned remainingNanoSteps = this->initializer->maxSteps() *  
    76             CELL_TYPE::nanoSteps() - nanoStepCounter; 
    77         nanoStep(remainingNanoSteps); 
     76        // unsigned remainingNanoSteps = this->initializer->maxSteps() *  
     77        //     CELL_TYPE::nanoSteps() - nanoStepCounter; 
     78        // nanoStep(remainingNanoSteps); 
    7879    } 
    7980 
    … …  
    8182    inline void step() 
    8283    { 
    83         nanoStep(CELL_TYPE::nanoSteps()); 
     84        // nanoStep(CELL_TYPE::nanoSteps()); 
    8485    } 
    8586 
    … …  
    8990        const Region<2> **validRegion)  
    9091    { 
    91         *validRegion = &partitionManager.ownRegion(); 
    92     } 
    93  
    94     inline const DisplacedGrid<CELL_TYPE> *getDisplacedGrid() 
    95     {         
    96         return 0; 
    97         // return regionStepper.getGrid(); 
    98     } 
     92        // *validRegion = &partitionManager.ownRegion(); 
     93    } 
     94 
     95    // inline const DisplacedGrid<CELL_TYPE> *getDisplacedGrid() 
     96    // {         
     97    //     return 0; 
     98    //     // return regionStepper.getGrid(); 
     99    // } 
    99100 
    100101private: 
    101 //     SuperMap<unsigned, Outgroup<PARTITION> > outgroups; 
    102     // fixme: who deletes the balancer? 
    103     LoadBalancer *balancer; 
    104     unsigned outputPeriod; 
     102    boost::shared_ptr<LoadBalancer> balancer; 
    105103    unsigned loadBalancingPeriod; 
    106     unsigned nanoStepCounter; 
     104    unsigned ghostZoneWidth; 
    107105    EventMap events; 
    108     PartitionManager<2> partitionManager; 
    109     unsigned root;     
    110     // fixme: can we get rid of this? 
    111     MPILayer mpiLayer; 
    112     unsigned eventRepetitionHorizon; 
    113  
    114     inline void nanoStep(const unsigned& s) 
    115     { 
    116         unsigned endNanoStep = nanoStepCounter + s; 
    117         events[endNanoStep].insert(PAUSE); 
     106    PartitionManager<DIM, Topology> partitionManager; 
     107    MPI::Comm *communicator; 
     108    boost::shared_ptr<UpdateGroup<CELL_TYPE, PARTITION> > updateGroup; 
     109 
     110    SuperVector<long> initialWeights(const long& items, const long& size) const 
     111    {     
     112        SuperVector<long> ret(size); 
     113        long lastPos = 0; 
     114 
     115        for (long i = 0; i < size; i++) { 
     116            long currentPos = items * (i + 1) / size; 
     117            ret[i] = currentPos - lastPos; 
     118            lastPos = currentPos; 
     119        } 
     120 
     121        return ret; 
     122    } 
     123 
     124//     inline void nanoStep(const unsigned& s) 
     125//     { 
     126//         unsigned endNanoStep = nanoStepCounter + s; 
     127//         events[endNanoStep].insert(PAUSE); 
    118128         
    119         while (nanoStepCounter < endNanoStep) { 
    120             std::pair<unsigned, EventSet> currentEvents = extractCurrentEvents(); 
    121             nanoStepCounter = currentEvents.first; 
    122             handleEvents(currentEvents.second); 
    123         } 
    124     } 
    125  
    126     inline std::pair<unsigned, EventSet> extractCurrentEvents() 
    127     { 
    128         EventMap::iterator curEventsPair = events.begin(); 
    129         unsigned curStop  = curEventsPair->first; 
    130         EventSet curEvents = curEventsPair->second; 
    131         if (curStop < nanoStepCounter) 
    132             throw std::logic_error("Stale events found in event point queue"); 
    133         events.erase(curEventsPair); 
    134         return std::make_pair(curStop, curEvents); 
    135     } 
    136  
    137  
    138     inline void handleEvents(const EventSet& curEvents) 
    139     { 
    140         //fixme: handle events 
    141         //             for (EventSet::iterator event = curEvents.begin(); event != curEvents.end(); ++event)  
    142         //                 std::cout << "  nanoStep: " << nanoStepCounter << " got event: " << eventToStr(*event) << "\n"; 
    143         //             if (curEvents.size() > 1) 
    144         //                 std::cout << "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"; 
    145         //             std::cout << "\n"; 
     129//         while (nanoStepCounter < endNanoStep) { 
     130//             std::pair<unsigned, EventSet> currentEvents = extractCurrentEvents(); 
     131//             nanoStepCounter = currentEvents.first; 
     132//             handleEvents(currentEvents.second); 
     133//         } 
     134//     } 
     135 
     136//     inline std::pair<unsigned, EventSet> extractCurrentEvents() 
     137//     { 
     138//         EventMap::iterator curEventsPair = events.begin(); 
     139//         unsigned curStop  = curEventsPair->first; 
     140//         EventSet curEvents = curEventsPair->second; 
     141//         if (curStop < nanoStepCounter) 
     142//             throw std::logic_error("Stale events found in event point queue"); 
     143//         events.erase(curEventsPair); 
     144//         return std::make_pair(curStop, curEvents); 
     145//     } 
     146 
     147 
     148//     inline void handleEvents(const EventSet& curEvents) 
     149//     { 
     150//         //fixme: handle events 
     151//         //             for (EventSet::iterator event = curEvents.begin(); event != curEvents.end(); ++event)  
     152//         //                 std::cout << "  nanoStep: " << nanoStepCounter << " got event: " << eventToStr(*event) << "\n"; 
     153//         //             if (curEvents.size() > 1) 
     154//         //                 std::cout << "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\n"; 
     155//         //             std::cout << "\n"; 
    146156             
    147         if (curEvents.count(OUTPUT))  
    148             events[this->nextOutput(eventRepetitionHorizon)].insert(OUTPUT); 
    149         if (curEvents.count(LOAD_BALANCING)) 
    150             events[this->nextLoadBalancing(eventRepetitionHorizon)].insert(LOAD_BALANCING); 
    151     } 
    152  
    153  
    154     inline void resetSimulation(const unsigned &ghostZoneWidth) 
    155     { 
    156         // this->resetEvents(); 
    157         // this->resetRegions(ghostZoneWidth); 
    158     } 
    159  
    160     inline void resetRegions(const unsigned &ghostZoneWidth) 
    161     { 
    162         partitionManager.resetRegions( 
    163             CoordBox<2>(Coord<2>(),  
    164                         this->initializer->gridDimensions()), 
    165             new VanillaRegionAccumulator<PARTITION>( 
    166             myPartition(), 
    167             myOffset(), 
    168             initialWeights()), 
    169             mpiLayer.rank(), 
    170             ghostZoneWidth); 
    171  
    172         SuperVector<CoordBox<2> > boundingBoxes(mpiLayer.size()); 
    173         CoordBox<2> ownBoundingBox(partitionManager.ownRegion().boundingBox()); 
    174         mpiLayer.allGather(ownBoundingBox, &boundingBoxes); 
    175         partitionManager.resetGhostZones(boundingBoxes); 
    176         // fixme: care for validGhostZoneWidth 
    177     } 
    178  
    179     inline SuperVector<unsigned> initialWeights() const 
    180     { 
    181         SuperVector<unsigned> weights(mpiLayer.size()); 
    182         if (mpiLayer.rank() == root) { 
    183             unsigned remainingCells = this->initializer->gridBox().size(); 
    184             for (unsigned i = mpiLayer.size(); i > 0; --i) { 
    185                 unsigned curWeight = (unsigned)round((double)remainingCells / i); 
    186                 weights[i - 1] = curWeight; 
    187                 remainingCells -= curWeight; 
    188             } 
    189         } 
    190         mpiLayer.broadcastVector(&weights, root); 
    191         return weights; 
    192     } 
     157//         if (curEvents.count(OUTPUT))  
     158//             events[this->nextOutput(eventRepetitionHorizon)].insert(OUTPUT); 
     159//         if (curEvents.count(LOAD_BALANCING)) 
     160//             events[this->nextLoadBalancing(eventRepetitionHorizon)].insert(LOAD_BALANCING); 
     161//     } 
     162 
     163 
     164//     inline void resetSimulation(const unsigned &ghostZoneWidth) 
     165//     { 
     166//         // this->resetEvents(); 
     167//         // this->resetRegions(ghostZoneWidth); 
     168//     } 
     169 
     170//     inline void resetRegions(const unsigned &ghostZoneWidth) 
     171//     { 
     172//         partitionManager.resetRegions( 
     173//             CoordBox<2>(Coord<2>(),  
     174//                         this->initializer->gridDimensions()), 
     175//             new VanillaRegionAccumulator<PARTITION>( 
     176//             myPartition(), 
     177//             myOffset(), 
     178//             initialWeights()), 
     179//             mpiLayer.rank(), 
     180//             ghostZoneWidth); 
     181 
     182//         SuperVector<CoordBox<2> > boundingBoxes(mpiLayer.size()); 
     183//         CoordBox<2> ownBoundingBox(partitionManager.ownRegion().boundingBox()); 
     184//         mpiLayer.allGather(ownBoundingBox, &boundingBoxes); 
     185//         partitionManager.resetGhostZones(boundingBoxes); 
     186//         // fixme: care for validGhostZoneWidth 
     187//     } 
     188 
     189//     inline SuperVector<unsigned> initialWeights() const 
     190//     { 
     191//         SuperVector<unsigned> weights(mpiLayer.size()); 
     192//         if (mpiLayer.rank() == root) { 
     193//             unsigned remainingCells = this->initializer->gridBox().size(); 
     194//             for (unsigned i = mpiLayer.size(); i > 0; --i) { 
     195//                 unsigned curWeight = (unsigned)round((double)remainingCells / i); 
     196//                 weights[i - 1] = curWeight; 
     197//                 remainingCells -= curWeight; 
     198//             } 
     199//         } 
     200//         mpiLayer.broadcastVector(&weights, root); 
     201//         return weights; 
     202//     } 
    193203     
    194     inline void resetEvents() 
    195     { 
    196         nanoStepCounter = this->initializer->startStep() * CELL_TYPE::nanoSteps(); 
    197         events.clear(); 
    198         unsigned firstOutput        = ((int)ceil(nanoStepCounter / (double)outputPeriod))        * outputPeriod; 
    199         unsigned firstLoadBalancing = ((int)ceil(nanoStepCounter / (double)loadBalancingPeriod)) * loadBalancingPeriod; 
    200         for (int i = 0; i < eventRepetitionHorizon; ++i) { 
    201             events[firstOutput        + i * outputPeriod       ].insert(OUTPUT); 
    202             events[firstLoadBalancing + i * loadBalancingPeriod].insert(LOAD_BALANCING); 
    203         } 
    204         events[this->initializer->maxSteps() * CELL_TYPE::nanoSteps()].insert(SIMULATION_END); 
    205     } 
    206  
    207     inline unsigned nextOutput(const unsigned& horizon=1) const 
    208     { 
    209         return (nanoStepCounter / outputPeriod + horizon) * outputPeriod; 
    210     }     
    211  
    212     inline unsigned nextLoadBalancing(const unsigned horizon=1) const 
    213     { 
    214         return (nanoStepCounter / loadBalancingPeriod + horizon) * loadBalancingPeriod; 
    215     }     
    216  
    217     inline Region<2> allGatherGroupRegion()  
    218     { 
    219         return allGatherGroupRegion(partitionManager.ownRegion()); 
    220     } 
    221  
    222     inline Region<2> allGatherGroupRegion(const Region<2>& region)  
    223     { 
    224         int streakNum = region.numStreaks(); 
    225         SuperVector<int> streakNums(mpiLayer.allGather(streakNum)); 
    226         SuperVector<Streak<2> > ownStreaks(region.toVector()); 
    227         SuperVector<Streak<2> > allStreaks(mpiLayer.allGatherV(&ownStreaks[0], streakNums)); 
    228         Region<2> ret; 
    229         for (SuperVector<Streak<2> >::iterator i = allStreaks.begin();  
    230              i != allStreaks.end(); ++i) 
    231             ret << *i; 
    232         return ret; 
    233     } 
    234  
    235     inline void registerOutgroupRegion(const unsigned& relativeLevel, const Region<2>& region) 
    236     { 
    237 //         outgroupSteppers[relativeLevel].resetRegions( 
    238  
    239 // IntersectingRegionAccumulator<PARTITION>(region, myPartition(), myOffset(), initialWeights()); 
    240     } 
    241  
    242     inline void updateOutgroupRegion(const unsigned& relativeLevel, const unsigned& steps) 
    243     { 
     204//     inline void resetEvents() 
     205//     { 
     206//         nanoStepCounter = this->initializer->startStep() * CELL_TYPE::nanoSteps(); 
     207//         events.clear(); 
     208//         unsigned firstOutput        = ((int)ceil(nanoStepCounter / (double)outputPeriod))        * outputPeriod; 
     209//         unsigned firstLoadBalancing = ((int)ceil(nanoStepCounter / (double)loadBalancingPeriod)) * loadBalancingPeriod; 
     210//         for (int i = 0; i < eventRepetitionHorizon; ++i) { 
     211//             events[firstOutput        + i * outputPeriod       ].insert(OUTPUT); 
     212//             events[firstLoadBalancing + i * loadBalancingPeriod].insert(LOAD_BALANCING); 
     213//         } 
     214//         events[this->initializer->maxSteps() * CELL_TYPE::nanoSteps()].insert(SIMULATION_END); 
     215//     } 
     216 
     217//     inline unsigned nextOutput(const unsigned& horizon=1) const 
     218//     { 
     219//         return (nanoStepCounter / outputPeriod + horizon) * outputPeriod; 
     220//     }     
     221 
     222//     inline unsigned nextLoadBalancing(const unsigned horizon=1) const 
     223//     { 
     224//         return (nanoStepCounter / loadBalancingPeriod + horizon) * loadBalancingPeriod; 
     225//     }     
     226 
     227//     inline Region<2> allGatherGroupRegion()  
     228//     { 
     229//         return allGatherGroupRegion(partitionManager.ownRegion()); 
     230//     } 
     231 
     232//     inline Region<2> allGatherGroupRegion(const Region<2>& region)  
     233//     { 
     234//         int streakNum = region.numStreaks(); 
     235//         SuperVector<int> streakNums(mpiLayer.allGather(streakNum)); 
     236//         SuperVector<Streak<2> > ownStreaks(region.toVector()); 
     237//         SuperVector<Streak<2> > allStreaks(mpiLayer.allGatherV(&ownStreaks[0], streakNums)); 
     238//         Region<2> ret; 
     239//         for (SuperVector<Streak<2> >::iterator i = allStreaks.begin();  
     240//              i != allStreaks.end(); ++i) 
     241//             ret << *i; 
     242//         return ret; 
     243//     } 
     244 
     245//     inline void registerOutgroupRegion(const unsigned& relativeLevel, const Region<2>& region) 
     246//     { 
     247// //         outgroupSteppers[relativeLevel].resetRegions( 
     248 
     249// // IntersectingRegionAccumulator<PARTITION>(region, myPartition(), myOffset(), initialWeights()); 
     250//     } 
     251 
     252//     inline void updateOutgroupRegion(const unsigned& relativeLevel, const unsigned& steps) 
     253//     { 
    244254         
    245     } 
    246  
    247     inline PARTITION myPartition() const 
    248     { 
    249         return PARTITION(Coord<2>(0, 0),  
    250                          this->initializer->gridDimensions()); 
    251     } 
    252  
    253     inline unsigned myOffset() const 
    254     { 
    255         return 0; 
    256     } 
     255//     } 
     256 
     257//     inline PARTITION myPartition() const 
     258//     { 
     259//         return PARTITION(Coord<2>(0, 0),  
     260//                          this->initializer->gridDimensions()); 
     261//     } 
     262 
     263//     inline unsigned myOffset() const 
     264//     { 
     265//         return 0; 
     266//     } 
    257267 
    258268}; 

  • src/parallelization/hiparsimulator/intersectingregionaccumulator.h

    r108 r127  
    1818        const Region<DIM>& _intersectionRegion, 
    1919        const PARTITION& _partition,  
    20         const unsigned& offset=0, 
    21         const SuperVector<unsigned>& weights=SuperVector<unsigned>()) : 
     20        const long& offset=0, 
     21        const SuperVector<long>& weights=SuperVector<long>()) : 
    2222        VanillaRegionAccumulator<PARTITION>(_partition, offset, weights), 
    2323        intersectionRegion(_intersectionRegion) 
    2424    {} 
    2525 
    26     inline virtual Region<DIM> getRegion(const unsigned& node) 
     26    inline virtual Region<DIM> getRegion(const long& node) 
    2727    { 
    2828        return this->VanillaRegionAccumulator<PARTITION>::getRegion(node) & intersectionRegion; 

  • src/parallelization/hiparsimulator/partitionmanager.h

    r108 r127  
    3030        const CoordBox<DIM>& _simulationArea=CoordBox<DIM>()) 
    3131    { 
    32         SuperVector<unsigned> weights(1, _simulationArea.size()); 
     32        SuperVector<long> weights(1, _simulationArea.size()); 
    3333        StripingPartition<DIM> partition( 
    3434            Coord<DIM>(), _simulationArea.dimensions); 

  • src/parallelization/hiparsimulator/regionaccumulator.h

    r0 r127  
    1313{ 
    1414public: 
    15     virtual Region<DIM> getRegion(const unsigned& node) = 0; 
     15    virtual Region<DIM> getRegion(const long& node) = 0; 
    1616}; 
    1717 

  • src/parallelization/hiparsimulator/stepper.h

    r119 r127  
    4141    inline Stepper( 
    4242        const boost::shared_ptr<MyPartitionManager>& _partitionManager, 
    43         const boost::shared_ptr<Initializer<CELL_TYPE> >& _initializer) : 
     43        Initializer<CELL_TYPE>  *_initializer) : 
    4444        partitionManager(_partitionManager), 
    4545        initializer(_initializer) 
    … …  
    6969protected: 
    7070    boost::shared_ptr<MyPartitionManager> partitionManager; 
    71     boost::shared_ptr<Initializer<CELL_TYPE> > initializer; 
     71    Initializer<CELL_TYPE> *initializer; 
    7272    PatchProviderList patchProviders[2]; 
    7373    PatchAccepterList patchAccepters[2]; 

  • src/parallelization/hiparsimulator/test/parallel_mpi_1/innersetmarkertest.h

    r108 r127  
    2828        ghostZoneWidth = 6; 
    2929        rank = 0; 
    30         weights = SuperVector<unsigned> (9, 30 * dimensions.x()); 
     30        weights = SuperVector<long> (9, 30 * dimensions.x()); 
    3131        weights[3] = 40 * dimensions.x(); 
    3232        weights[5] = 20 * dimensions.x(); 
    … …  
    6565    StripingPartition<2> partition; 
    6666    Coord<2> dimensions; 
    67     SuperVector<unsigned> weights; 
     67    SuperVector<long> weights; 
    6868    unsigned startLine; 
    6969    unsigned offset; 

  • src/parallelization/hiparsimulator/test/parallel_mpi_1/intersectingregionaccumulatortest.h

    r108 r127  
    2121 
    2222        unsigned offset = 9; 
    23         SuperVector<unsigned> weights; 
     23        SuperVector<long> weights; 
    2424        weights += 25, 58, 8; 
    2525        Region<2> overlay; 

  • src/parallelization/hiparsimulator/test/parallel_mpi_1/partitionmanagertest.h

    r108 r127  
    1919        offset = 10 * 20 + 8; 
    2020        partition = StripingPartition<2>(Coord<2>(), dimensions); 
     21        weights.clear(); 
    2122        weights += 15, 12, 1, 32, 25, 40, 67; 
    2223        /** 
    … …  
    144145 
    145146        StripingPartition<3> partition(Coord<3>(), box.dimensions); 
    146         SuperVector<unsigned> weights; 
    147         weights << 10000; 
    148         weights << 15000; 
    149         weights << 25000; 
     147        SuperVector<long> weights; 
     148        weights += 10000, 15000, 25000; 
    150149        weights << box.dimensions.prod() - weights.sum(); 
    151150 
    … …  
    189188    unsigned offset; 
    190189    StripingPartition<2> partition; 
    191     SuperVector<unsigned> weights; 
     190    SuperVector<long> weights; 
    192191    unsigned rank; 
    193192    unsigned ghostZoneWidth; 
    … …  
    199198        const unsigned& size, 
    200199        const unsigned& ghostZoneWidth, 
    201         const SuperVector<unsigned>& weights, 
     200        const SuperVector<long>& weights, 
    202201        const StripingPartition<2>& partition) 
    203202    { 
    204203        SuperVector<CoordBox<2> > boundingBoxes(size); 
    205         unsigned startOffset = offset; 
    206         unsigned endOffset = offset; 
     204        long startOffset = offset; 
     205        long endOffset = offset; 
    207206        for (unsigned i = 0; i < size; ++i) { 
    208207            endOffset += weights[i]; 

  • src/parallelization/hiparsimulator/test/parallel_mpi_1/rimmarkertest.h

    r108 r127  
    2828        ghostZoneWidth = 6; 
    2929        rank = 0; 
    30         weights = SuperVector<unsigned> (9, 30 * dimensions.x()); 
     30        weights = SuperVector<long> (9, 30 * dimensions.x()); 
    3131        weights[3] = 40 * dimensions.x(); 
    3232        weights[5] = 20 * dimensions.x(); 
    … …  
    7070    StripingPartition<2> partition; 
    7171    Coord<2> dimensions; 
    72     SuperVector<unsigned> weights; 
     72    SuperVector<long> weights; 
    7373    unsigned startLine; 
    7474    unsigned offset; 

  • src/parallelization/hiparsimulator/test/parallel_mpi_1/updategrouptest.h

    r118 r127  
    3333        weights << dimensions.prod(); 
    3434        ghostZoneWidth = 10; 
    35         init.reset(new TestInitializer<3>(dimensions)); 
     35        init = new TestInitializer<3>(dimensions); 
    3636        updateGroup.reset( 
    3737            new MyUpdateGroup( 
    38                 Partition(Coord<3>(), dimensions), 
     38                partition, 
    3939                weights, 
    4040                0, 
    … …  
    5151    void tearDown() 
    5252    { 
    53         init.reset(); 
     53        delete init; 
    5454        updateGroup.reset(); 
    5555    } 
    … …  
    7070    unsigned rank; 
    7171    Coord<3> dimensions; 
    72     SuperVector<unsigned> weights; 
     72    SuperVector<long> weights; 
    7373    Partition partition; 
    7474    unsigned ghostZoneWidth; 
    75     boost::shared_ptr<Initializer<TestCell<3> > > init; 
     75    Initializer<TestCell<3> > *init; 
    7676    boost::shared_ptr<UpdateGroup<TestCell<3>, Partition > > updateGroup; 
    7777    boost::shared_ptr<MockPatchAccepter<GridType> > mockPatchAccepter; 

  • src/parallelization/hiparsimulator/test/parallel_mpi_1/vanillaregionaccumulatortest.h

    r108 r127  
    2323 
    2424        unsigned offset = 9; 
    25         SuperVector<unsigned> weights; 
     25        SuperVector<long> weights; 
    2626        weights += 25, 58, 8; 
    2727        // should look like this: 

  • src/parallelization/hiparsimulator/test/parallel_mpi_1/vanillastepperbasictest.h

    r110 r127  
    3030        partitionManager.reset(new PartitionManager<2>(rect)); 
    3131        stepper.reset( 
    32             new MyStepper(partitionManager, init)); 
     32            new MyStepper(partitionManager, &*init)); 
    3333 
    3434        stepper->addPatchAccepter(patchAccepter, MyStepper::GHOST); 

  • src/parallelization/hiparsimulator/test/parallel_mpi_1/vanillastepperregiontest.h

    r108 r127  
    5959        // between the two others 0 and 2. 
    6060        StripingPartition<2> partition(Coord<2>(0, 0), rect.dimensions); 
    61         SuperVector<unsigned> weights(3); 
     61        SuperVector<long> weights(3); 
    6262        weights[0] = 4*17 + 7; 
    6363        weights[1] = 2*17 - 1; 
    … …  
    8282 
    8383        // The Unit Under Test: the stepper 
    84         stepper.reset(new MyStepper(partitionManager, init)); 
     84        stepper.reset(new MyStepper(partitionManager, &*init)); 
    8585    } 
    8686 

  • src/parallelization/hiparsimulator/test/parallel_mpi_4/updategrouptest.h

    r118 r127  
    2929        weights = genWeights(dimensions.x(), dimensions.y(), MPILayer().size()); 
    3030        ghostZoneWidth = 10; 
    31         init.reset(new TestInitializer<2>(dimensions)); 
     31        init = new TestInitializer<2>(dimensions); 
    3232        updateGroup.reset( 
    3333            new MyUpdateGroup( 
    … …  
    4747    void tearDown() 
    4848    { 
    49         init.reset(); 
     49        delete init; 
    5050        updateGroup.reset(); 
    5151    } 
    … …  
    5959    unsigned rank; 
    6060    Coord<2> dimensions; 
    61     SuperVector<unsigned> weights; 
     61    SuperVector<long> weights; 
    6262    Partition partition; 
    6363    unsigned ghostZoneWidth; 
    64     boost::shared_ptr<Initializer<TestCell<2> > > init; 
     64    Initializer<TestCell<2> > *init; 
    6565    boost::shared_ptr<UpdateGroup<TestCell<2>, Partition > > updateGroup; 
    6666    boost::shared_ptr<MockPatchAccepter<GridType> > mockPatchAccepter; 
    6767 
    68     SuperVector<unsigned> genWeights( 
     68    SuperVector<long> genWeights( 
    6969        const unsigned& width,  
    7070        const unsigned& height,  
    7171        const unsigned& size) 
    7272    { 
    73         SuperVector<unsigned> ret(size); 
     73        SuperVector<long> ret(size); 
    7474        unsigned totalSize = width * height; 
    7575        for (int i = 0; i < ret.size(); ++i)  
    … …  
    7878    } 
    7979 
    80     unsigned pos(const unsigned& i, const unsigned& size, const unsigned& totalSize) 
     80    long pos(const unsigned& i, const unsigned& size, const unsigned& totalSize) 
    8181    { 
    8282        return i * totalSize / size; 

  • src/parallelization/hiparsimulator/test/parallel_mpi_4/vanillasteppertest.h

    r119 r127  
     1#include <boost/assign/std/vector.hpp> 
    12#include <cxxtest/TestSuite.h> 
    23 
    … …  
    89#include <libgeodecomp/parallelization/hiparsimulator/vanillastepper.h> 
    910 
     11using namespace boost::assign; 
    1012using namespace LibGeoDecomp;  
    1113using namespace HiParSimulator;  
    … …  
    7375 
    7476        StripingPartition<3> partition(Coord<3>(), box.dimensions); 
    75         SuperVector<unsigned> weights; 
    76         weights << 10000; 
    77         weights << 15000; 
    78         weights << 25000; 
     77        SuperVector<long> weights; 
     78        weights += 10000, 15000, 25000; 
    7979        weights << box.dimensions.prod() - weights.sum(); 
    8080 
    … …  
    9494        partitionManager->resetGhostZones(boundingBoxes); 
    9595        
    96         stepper.reset(new MyStepper(partitionManager, init)); 
     96        stepper.reset(new MyStepper(partitionManager, &*init)); 
    9797 
    9898        // verify that the grids got set up properly 

  • src/parallelization/hiparsimulator/test/parallel_mpi_9/partitionmanagertest.h

    r108 r127  
    2929        offset = 130 * dimensions.x(); 
    3030        ghostZoneWidth = 6; 
    31         weights = SuperVector<unsigned>(layer.size(), 30 * dimensions.x()); 
     31        weights = SuperVector<long>(layer.size(), 30 * dimensions.x()); 
    3232        weights[3] = 40 * dimensions.x(); 
    3333        weights[5] = 20 * dimensions.x(); 
    … …  
    169169    StripingPartition<2> partition; 
    170170    Coord<2> dimensions; 
    171     SuperVector<unsigned> weights; 
     171    SuperVector<long> weights; 
    172172    unsigned offset; 
    173173    unsigned ghostZoneWidth; 

  • src/parallelization/hiparsimulator/updategroup.h

    r118 r127  
    3838    UpdateGroup( 
    3939        const PARTITION& _partition,  
    40         const SuperVector<unsigned>& _weights,  
     40        const SuperVector<long>& _weights,  
    4141        const unsigned& _offset, 
    4242        const CoordBox<DIM>& box,  
    4343        const unsigned& _ghostZoneWidth, 
    44         boost::shared_ptr<Initializer<CELL_TYPE> > _initializer, 
     44        Initializer<CELL_TYPE> *_initializer, 
    4545        MPI::Comm *communicator = &MPI::COMM_WORLD) :  
    4646        partition(_partition), 
    … …  
    6666        partitionManager->resetGhostZones(boundingBoxes); 
    6767 
    68         stepper.reset( new STEPPER( partitionManager, initializer)); 
     68        stepper.reset(new STEPPER( partitionManager, initializer)); 
    6969 
    7070        RegionVecMap map = partitionManager->getInnerGhostZoneFragments(); 
    … …  
    125125    SuperVector<PatchLinkPtr> patchLinks; 
    126126    PARTITION partition; 
    127     SuperVector<unsigned> weights; 
     127    SuperVector<long> weights; 
    128128    unsigned offset; 
    129129    unsigned ghostZoneWidth; 
    130     boost::shared_ptr<Initializer<CELL_TYPE> > initializer; 
     130    Initializer<CELL_TYPE> *initializer; 
    131131    MPILayer mpiLayer; 
    132132    unsigned rank; 

  • src/parallelization/hiparsimulator/vanillaregionaccumulator.h

    r108 r127  
    1818    inline VanillaRegionAccumulator( 
    1919        const PARTITION& _partition=PARTITION(),  
    20         const unsigned& offset=0, 
    21         const SuperVector<unsigned>& weights=SuperVector<unsigned>(2)) : 
     20        const long& offset=0, 
     21        const SuperVector<long>& weights=SuperVector<long>(2)) : 
    2222        partition(_partition) 
    2323    { 
    2424        startOffsets.resize(weights.size() + 1); 
    2525        startOffsets[0] = offset; 
    26         for (unsigned i = 0; i < weights.size(); ++i) 
     26        for (long i = 0; i < weights.size(); ++i) 
    2727            startOffsets[i + 1] = startOffsets[i] + weights[i];         
    2828    } 
    2929 
    30     inline virtual Region<DIM> getRegion(const unsigned& node) 
     30    inline virtual Region<DIM> getRegion(const long& node) 
    3131    { 
    3232        return Region<DIM>( 
    … …  
    3737private: 
    3838    PARTITION partition; 
    39     SuperVector<unsigned> startOffsets; 
     39    SuperVector<long> startOffsets; 
    4040}; 
    4141 

  • src/parallelization/hiparsimulator/vanillastepper.h

    r119 r127  
    2828    inline VanillaStepper( 
    2929        boost::shared_ptr<MyPartitionManager> _partitionManager, 
    30         boost::shared_ptr<Initializer<CELL_TYPE> > _initializer) : 
     30        Initializer<CELL_TYPE> *_initializer) : 
    3131        ParentType(_partitionManager, _initializer) 
    3232    { 

  • src/parallelization/simulator.h

    r0 r127  
    2020    typedef Grid<CELL_TYPE, Topology> GridType; 
    2121     
     22    inline Simulator(Initializer<CELL_TYPE> *_initializer) :  
     23        stepNum(0),  
     24        initializer(_initializer) 
     25    {} 
     26 
    2227    inline virtual ~Simulator()  
    2328    {  
    2429        delete initializer; 
    2530    } 
    26  
    27     inline Simulator(Initializer<CELL_TYPE> *_initializer) :  
    28         stepNum(0), initializer(_initializer) 
    29     {} 
    3031 
    3132    /** 

  • src/parallelization/test/parallel_mpi_1/hiparsimulatortest.h

    r108 r127  
    3232        ghostzZoneWidth = 10; 
    3333        s.reset(new HiParSimulator<TestCell<2>, StripingPartition<2> >( 
    34                     init, 0, outputPeriod, loadBalancingPeriod, ghostzZoneWidth)); 
     34                    init, 0, loadBalancingPeriod, ghostzZoneWidth)); 
    3535        // fixme 
    3636        // mockWriter = new MockWriter(&(*s)); 

  • src/parallelization/test/parallel_mpi_4/hiparsimulatortest.h

    r108 r127  
    3232        ghostZoneWidth = 10; 
    3333        s.reset(new HiParSimulator<TestCell<2>, StripingPartition<2> >( 
    34                     init, 0, outputPeriod,  
    35                     loadBalancingPeriod, ghostZoneWidth)); 
     34                    init, 0, loadBalancingPeriod, ghostZoneWidth)); 
    3635        // mockWriter = new MockWriter(&(*s)); 
    3736    }