Ignore:
Timestamp:
06/12/23 11:52:10 (13 months ago)
Author:
ymipsl
Message:

New way to manage locks in window manager. Windows is locked with MPI_Win_lock_all at creation (shared mode), and lock is manage by software way in the class (using MPI_swap_and_compare and MPI_Fetch_op). We get in this case a better control of lock, with controled latency between each attemp of lock.

YM

File:
1 edited

Legend:

Unmodified
Added
Removed

  • XIOS3/trunk/src/manager/window_manager.hpp

    r2263 r2517  
    77#include "buffer_out.hpp" 
    88#include "message.hpp" 
     9#include "window_base.hpp" 
    910 
    1011namespace xios 
    … …  
    1213 
    1314 
    14   class CWindowManager 
     15  class CWindowManager : public CWindowBase  
    1516  { 
    1617 
    1718    private : 
    18     const MPI_Aint OFFSET_LOCK=0 ; 
    19     const int SIZE_LOCK=sizeof(int) ; 
    20     const MPI_Aint OFFSET_BUFFER_SIZE=OFFSET_LOCK+SIZE_LOCK ; 
    21     const int SIZE_BUFFER_SIZE=sizeof(size_t) ; 
    22     const MPI_Aint OFFSET_BUFFER=OFFSET_BUFFER_SIZE+SIZE_BUFFER_SIZE ; 
    23     const int WINDOWS_LOCKED=-1 ; 
     19    static const MPI_Aint OFFSET_LOCK=0 ; 
     20    static const int SIZE_LOCK=sizeof(int) ; 
     21    static const MPI_Aint OFFSET_BUFFER_SIZE=OFFSET_LOCK+SIZE_LOCK ; 
     22    static const int SIZE_BUFFER_SIZE=sizeof(size_t) ; 
     23    static const MPI_Aint OFFSET_BUFFER=OFFSET_BUFFER_SIZE+SIZE_BUFFER_SIZE ; 
     24    static const int WINDOWS_LOCKED=-1 ; 
    2425 
    2526    MPI_Win window_ ; 
    … …  
    3031    public : 
    3132 
    32     CWindowManager(MPI_Comm winComm, size_t bufferSize) 
    33     { 
    34       const MPI_Aint windowSize=bufferSize+OFFSET_BUFFER ; 
    35       MPI_Win_allocate(windowSize, 1, MPI_INFO_NULL, winComm, &winBuffer_, &window_) ; 
     33    CWindowManager(MPI_Comm winComm, size_t bufferSize) : CWindowBase(winComm, bufferSize + OFFSET_BUFFER_SIZE) 
     34    { 
    3635      int lock=0 ; 
    3736      size_t size=0 ; 
    3837      int commRank ; 
    3938      MPI_Comm_rank(winComm, &commRank) ; 
    40       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, commRank, 0, window_) ; 
    41       MPI_Put(&lock, SIZE_LOCK, MPI_CHAR, commRank, OFFSET_LOCK, SIZE_LOCK, MPI_CHAR, window_) ; 
    42       MPI_Put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, commRank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    43       MPI_Win_unlock(commRank, window_) ; 
     39      lockExclusive(commRank) ; 
     40      put(&lock, SIZE_LOCK, MPI_CHAR, commRank, OFFSET_LOCK, SIZE_LOCK, MPI_CHAR) ; 
     41      put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, commRank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR) ; 
     42      unlockExclusive(commRank) ; 
    4443      MPI_Barrier(winComm) ; 
    4544    } 
    … …  
    6362        int flag ; 
    6463        MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE); 
    65         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    66         MPI_Compare_and_swap(&WINDOWS_LOCKED, &state, &lock, MPI_INT, rank, OFFSET_LOCK, window_) ; 
    67         MPI_Win_unlock(rank, window_) ; 
     64        compareAndSwap(&WINDOWS_LOCKED, &state, &lock, MPI_INT, rank, OFFSET_LOCK) ; 
     65        flush(rank) ; 
    6866        lastTime=MPI_Wtime() ; 
    6967      } while (lock!=state) ; 
    … …  
    9088        int flag ; 
    9189        MPI_Iprobe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &flag, MPI_STATUS_IGNORE); 
    92         MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    93         MPI_Compare_and_swap(&WINDOWS_LOCKED, &state, &lock, MPI_INT, rank, OFFSET_LOCK, window_) ; 
    94         MPI_Win_unlock(rank, window_) ; 
     90        lockExclusive(rank) ; 
     91        compareAndSwap(&WINDOWS_LOCKED, &state, &lock, MPI_INT, rank, OFFSET_LOCK) ; 
     92        unlockExclusive(rank) ; 
    9593        lastTime=MPI_Wtime() ; 
    9694      } while (lock!=state) ; 
    … …  
    9997    void lockWindowExclusive(int rank) 
    10098    { 
    101       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
     99      lockExclusive(rank) ; 
    102100    } 
    103101 
    104102    void lockWindowShared(int rank) 
    105103    { 
    106       MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, window_) ; 
    107     } 
    108  
     104      lockShared(rank) ; 
     105    } 
     106 
     107    void unlockWindowExclusive(int rank) 
     108    { 
     109      unlockExclusive(rank) ; 
     110    } 
     111 
     112    void unlockWindowShared(int rank) 
     113    { 
     114      unlockShared(rank) ; 
     115    } 
     116 
     117    void lockWindow(int rank) 
     118    { 
     119      lockWindowExclusive(rank) ; 
     120    } 
     121     
    109122    void unlockWindow(int rank) 
    110123    { 
    111       MPI_Win_unlock(rank, window_) ; 
     124      unlockWindowExclusive(rank) ; 
    112125    } 
    113126 
    114127    void flushWindow(int rank) 
    115128    { 
    116       MPI_Win_flush(rank, window_) ; 
     129      flush(rank) ; 
    117130    } 
    118131 
    … …  
    120133    { 
    121134      int lock ; 
    122       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    123       MPI_Compare_and_swap(&state, &WINDOWS_LOCKED, &lock, MPI_INT, rank, OFFSET_LOCK, window_) ; 
    124       MPI_Win_unlock(rank, window_) ; 
     135      compareAndSwap(&state, &WINDOWS_LOCKED, &lock, MPI_INT, rank, OFFSET_LOCK) ; 
     136      flush(rank) ; 
    125137    } 
    126138     
    127139    template< class T > 
    128140    void updateToWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
     141    { 
     142      updateToExclusiveWindow(rank, object, dumpOut) ; 
     143    } 
     144 
     145    template< class T > 
     146    void updateToExclusiveWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
     147    { 
     148      lockExclusive(rank) ; 
     149      updateToLockedWindow(rank, object, dumpOut) ; 
     150      unlockExclusive(rank) ; 
     151     } 
     152 
     153    template< class T > 
     154    void updateTosharedWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
     155    { 
     156      lockShared(rank) ; 
     157      updateToLockedWindow(rank, object, dumpOut) ; 
     158      unlockShared(rank) ; 
     159    } 
     160 
     161    template< class T > 
     162    void updateToLockedWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
    129163    { 
    130164      CBufferOut buffer ; 
    131165      (object->*dumpOut)(buffer) ; 
    132166      size_t size=buffer.count() ; 
    133       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    134       MPI_Put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    135       MPI_Put(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    136       MPI_Win_unlock(rank, window_) ; 
    137     } 
    138  
    139     template< class T > 
    140     void updateToExclusiveWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
    141     { 
    142       CBufferOut buffer ; 
    143       (object->*dumpOut)(buffer) ; 
    144       size_t size=buffer.count() ; 
    145       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    146       MPI_Put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    147       MPI_Put(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    148       MPI_Win_unlock(rank, window_) ; 
    149     } 
    150  
    151     template< class T > 
    152     void updateTosharedWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
    153     { 
    154       CBufferOut buffer ; 
    155       (object->*dumpOut)(buffer) ; 
    156       size_t size=buffer.count() ; 
    157       MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, window_) ; 
    158       MPI_Put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    159       MPI_Put(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    160       MPI_Win_unlock(rank, window_) ; 
    161     } 
    162  
    163     template< class T > 
    164     void updateToLockedWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
    165     { 
    166       CBufferOut buffer ; 
    167       (object->*dumpOut)(buffer) ; 
    168       size_t size=buffer.count() ; 
    169 //      MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    170       MPI_Put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    171       MPI_Put(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    172       MPI_Win_flush(rank, window_) ; 
    173 //      MPI_Win_unlock(rank, window_) ; 
     167 
     168      put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR) ; 
     169      put(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR) ; 
     170      flush(rank) ; 
    174171    } 
    175172 
    … …  
    177174    void updateFromWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
    178175    { 
    179       size_t size ; 
    180       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    181       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    182       MPI_Win_flush(rank,window_) ; 
     176      updateFromExclusiveWindow(rank,object, dumpIn) ; 
     177    } 
     178 
     179    template< typename T > 
     180    void updateFromExclusiveWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
     181    { 
     182      size_t size ; 
     183      lockExclusive(rank) ; 
     184      updateFromLockedWindow(rank,object, dumpIn) ; 
     185      unlockExclusive(rank) ; 
     186    } 
     187 
     188    template< typename T > 
     189    void updateFromSharedWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
     190    { 
     191      size_t size ; 
     192      lockShared(rank) ; 
     193      updateFromLockedWindow(rank,object, dumpIn) ; 
     194      unlockShared(rank) ; 
     195    } 
     196 
     197    template< typename T > 
     198    void updateFromLockedWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
     199    { 
     200      size_t size ; 
     201 
     202      get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR) ; 
     203      flush(rank) ; 
    183204      CBufferIn buffer(size) ; 
    184       MPI_Get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    185       MPI_Win_unlock(rank, window_) ; 
     205      get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR) ; 
     206      flush(rank) ; 
     207 
    186208      (object->*dumpIn)(buffer) ; 
    187209    } 
    188210 
    189     template< typename T > 
    190     void updateFromExclusiveWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
    191     { 
    192       size_t size ; 
    193       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    194       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    195       MPI_Win_flush(rank,window_) ; 
    196       CBufferIn buffer(size) ; 
    197       MPI_Get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    198       MPI_Win_unlock(rank, window_) ; 
    199       (object->*dumpIn)(buffer) ; 
    200     } 
    201  
    202     template< typename T > 
    203     void updateFromSharedWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
    204     { 
    205       size_t size ; 
    206       MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, window_) ; 
    207       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    208       MPI_Win_flush(rank,window_) ; 
    209       CBufferIn buffer(size) ; 
    210       MPI_Get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    211       MPI_Win_unlock(rank, window_) ; 
    212       (object->*dumpIn)(buffer) ; 
    213     } 
    214  
    215     template< typename T > 
    216     void updateFromLockedWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
    217     { 
    218       size_t size ; 
    219 //      MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, window_) ; 
    220       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    221       MPI_Win_flush(rank,window_) ; 
    222       CBufferIn buffer(size) ; 
    223       MPI_Get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    224 //      MPI_Win_unlock(rank, window_) ; 
    225       MPI_Win_flush(rank, window_) ; 
    226       (object->*dumpIn)(buffer) ; 
    227     } 
    228211 
    229212 
    … …  
    231214    void pushToWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
    232215    { 
    233       size_t size ; 
    234       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    235       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    236       MPI_Win_flush(rank,window_) ; 
     216      pushToExclusiveWindow(rank, object, dumpOut) ; 
     217    } 
     218 
     219    template< class T > 
     220    void pushToExclusiveWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
     221    { 
     222      lockExclusive(rank) ; 
     223      pushToLockedWindow(rank, object, dumpOut) ; 
     224      unlockExclusive(rank) ; 
     225    } 
     226 
     227    template< class T > 
     228    void pushToSharedWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
     229    { 
     230      lockShared(rank) ; 
     231      pushToLockedWindow(rank, object, dumpOut) ; 
     232      unlockShared(rank) ; 
     233    } 
     234 
     235    template< class T > 
     236    void pushToLockedWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
     237    { 
     238      size_t size ; 
     239      get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR) ; 
     240      flush(rank) ; 
    237241      CBufferOut buffer ; 
    238242      (object->*dumpOut)(buffer) ; 
    239243      size_t bufferSize=buffer.count() ; 
    240244      size_t newSize = size + bufferSize; 
    241       MPI_Put(&newSize, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    242       MPI_Put(buffer.start(), bufferSize, MPI_CHAR, rank, OFFSET_BUFFER+size, bufferSize, MPI_CHAR, window_) ; 
    243       MPI_Win_unlock(rank, window_) ; 
    244     } 
    245  
    246     template< class T > 
    247     void pushToExclusiveWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
    248     { 
    249       size_t size ; 
    250       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    251       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    252       MPI_Win_flush(rank,window_) ; 
    253       CBufferOut buffer ; 
    254       (object->*dumpOut)(buffer) ; 
    255       size_t bufferSize=buffer.count() ; 
    256       size_t newSize = size + bufferSize; 
    257       MPI_Put(&newSize, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    258       MPI_Put(buffer.start(), bufferSize, MPI_CHAR, rank, OFFSET_BUFFER+size, bufferSize, MPI_CHAR, window_) ; 
    259       MPI_Win_unlock(rank, window_) ; 
    260     } 
    261  
    262     template< class T > 
    263     void pushToSharedWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
    264     { 
    265       size_t size ; 
    266       MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, window_) ; 
    267       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    268       MPI_Win_flush(rank,window_) ; 
    269       CBufferOut buffer ; 
    270       (object->*dumpOut)(buffer) ; 
    271       size_t bufferSize=buffer.count() ; 
    272       size_t newSize = size + bufferSize; 
    273       MPI_Put(&newSize, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    274       MPI_Put(buffer.start(), bufferSize, MPI_CHAR, rank, OFFSET_BUFFER+size, bufferSize, MPI_CHAR, window_) ; 
    275       MPI_Win_unlock(rank, window_) ; 
    276     } 
    277  
    278     template< class T > 
    279     void pushToLockedWindow(int rank, T* object, void (T::*dumpOut)(CBufferOut&) ) 
    280     { 
    281       size_t size ; 
    282       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    283       MPI_Win_flush(rank,window_) ; 
    284       CBufferOut buffer ; 
    285       (object->*dumpOut)(buffer) ; 
    286       size_t bufferSize=buffer.count() ; 
    287       size_t newSize = size + bufferSize; 
    288       MPI_Put(&newSize, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    289       MPI_Put(buffer.start(), bufferSize, MPI_CHAR, rank, OFFSET_BUFFER+size, bufferSize, MPI_CHAR, window_) ; 
    290       MPI_Win_flush(rank, window_) ; 
    291     } 
     245      put(&newSize, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR) ; 
     246      put(buffer.start(), bufferSize, MPI_CHAR, rank, OFFSET_BUFFER+size, bufferSize, MPI_CHAR) ; 
     247      flush(rank) ; 
     248    } 
     249 
     250 
    292251 
    293252    template< typename T > 
    294253    void popFromWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
    295254    { 
    296       size_t size ; 
    297       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    298       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    299       MPI_Win_flush(rank,window_) ; 
     255      popFromExclusiveWindow(rank,object, dumpIn) ;  
     256    } 
     257 
     258    template< typename T > 
     259    void popFromExclusiveWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
     260    { 
     261      lockExclusive(rank) ; 
     262      popFromLockedWindow(rank,object, dumpIn) ;  
     263      unlockExclusive(rank) ; 
     264       
     265    } 
     266 
     267    template< typename T > 
     268    void popFromSharedWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
     269    { 
     270      lockShared(rank) ; 
     271      popFromLockedWindow(rank,object, dumpIn) ;  
     272      unlockShared(rank) ; 
     273    } 
     274 
     275    template< typename T > 
     276    void popFromLockedWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
     277    { 
     278      size_t size ; 
     279      get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR) ; 
     280      flush(rank) ; 
    300281      CBufferIn buffer(size) ; 
    301       MPI_Get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    302       MPI_Win_flush(rank,window_) ; 
     282      get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR) ; 
     283      flush(rank) ; 
    303284      (object->*dumpIn)(buffer) ; 
    304285       
    305286      size=buffer.remain() ; 
    306       MPI_Put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    307       MPI_Put(buffer.ptr(),buffer.remain(), MPI_CHAR, rank, OFFSET_BUFFER, buffer.remain(), MPI_CHAR, window_) ; 
    308       MPI_Win_unlock(rank, window_) ; 
    309        
    310     } 
    311  
    312     template< typename T > 
    313     void popFromExclusiveWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
    314     { 
    315       size_t size ; 
    316       MPI_Win_lock(MPI_LOCK_EXCLUSIVE, rank, 0, window_) ; 
    317       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    318       MPI_Win_flush(rank,window_) ; 
    319       CBufferIn buffer(size) ; 
    320       MPI_Get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    321       MPI_Win_flush(rank,window_) ; 
    322       (object->*dumpIn)(buffer) ; 
    323        
    324       size=buffer.remain() ; 
    325       MPI_Put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    326       MPI_Put(buffer.ptr(),buffer.remain(), MPI_CHAR, rank, OFFSET_BUFFER, buffer.remain(), MPI_CHAR, window_) ; 
    327       MPI_Win_unlock(rank, window_) ; 
    328        
    329     } 
    330  
    331     template< typename T > 
    332     void popFromSharedWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
    333     { 
    334       size_t size ; 
    335       MPI_Win_lock(MPI_LOCK_SHARED, rank, 0, window_) ; 
    336       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    337       MPI_Win_flush(rank,window_) ; 
    338       CBufferIn buffer(size) ; 
    339       MPI_Get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    340       MPI_Win_flush(rank,window_) ; 
    341       (object->*dumpIn)(buffer) ; 
    342        
    343       size=buffer.remain() ; 
    344       MPI_Put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    345       MPI_Put(buffer.ptr(),buffer.remain(), MPI_CHAR, rank, OFFSET_BUFFER, buffer.remain(), MPI_CHAR, window_) ; 
    346       MPI_Win_unlock(rank, window_) ; 
    347        
    348     } 
    349  
    350     template< typename T > 
    351     void popFromLockedWindow(int rank, T* object, void (T::*dumpIn)(CBufferIn&) )  
    352     { 
    353       size_t size ; 
    354       MPI_Get(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    355       MPI_Win_flush(rank,window_) ; 
    356       CBufferIn buffer(size) ; 
    357       MPI_Get(buffer.start(), size, MPI_CHAR, rank,OFFSET_BUFFER, size, MPI_CHAR, window_) ; 
    358       MPI_Win_flush(rank,window_) ; 
    359       (object->*dumpIn)(buffer) ; 
    360        
    361       size=buffer.remain() ; 
    362       MPI_Put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR, window_) ; 
    363       MPI_Put(buffer.ptr(),buffer.remain(), MPI_CHAR, rank, OFFSET_BUFFER, buffer.remain(), MPI_CHAR, window_) ; 
    364       MPI_Win_flush(rank, window_) ; 
     287      put(&size, SIZE_BUFFER_SIZE, MPI_CHAR, rank, OFFSET_BUFFER_SIZE, SIZE_BUFFER_SIZE, MPI_CHAR) ; 
     288      put(buffer.ptr(),buffer.remain(), MPI_CHAR, rank, OFFSET_BUFFER, buffer.remain(), MPI_CHAR) ; 
     289      flush(rank) ; 
    365290    } 
    366291 
    367292    ~CWindowManager() 
    368293    { 
    369       MPI_Win_free(&window_) ; 
    370294    } 
    371295  } ; 
Note: See TracChangeset for help on using the changeset viewer.