void CValueObject_Ctor(CValueObject* pMe) { DECLARE_PVTBL(pvt, IValueObject); CBase_Ctor((CBase*)pMe); VT_FUNC(pvt, CValueObject, Release); VT_FUNC(pvt, CValueObject, SetValue); VT_FUNC(pvt, CValueObject, GetValue); }
void CEventDispatcher_Ctor(CEventDispatcher* pMe) { DECLARE_PVTBL(pvt, IEventDispatcher); CBase_Ctor(&pMe->base); pMe->m_pListeners = CVector_New(); IVector_SetPfnFree(pMe->m_pListeners, FREE); VT_FUNC(pvt, CEventDispatcher, Release); VT_FUNC(pvt, CEventDispatcher, AddListener); VT_FUNC(pvt, CEventDispatcher, RemoveListener); VT_FUNC(pvt, CEventDispatcher, Notify); }
// ******************************************************************************************* // init the matrix // executed once per tile; inits the tile-core and its borders (halo-region) int matrix_init::execute( const loop_tag & tag, my_context & c ) const { #ifdef CNC_WITH_ITAC VT_FUNC( "init" ); #endif const int NX = tag.x < c.BNX - 1 ? BSIZEX : c.BBSX; const int NY = tag.y < c.BNY - 1 ? BSIZEY : c.BBSY; const int NZ = tag.z < c.BNZ - 1 ? BSIZEZ : c.BBSZ; const int Nx = c.Nx + 2*HSIZE; const int Ny = c.Ny + 2*HSIZE; const int Nz = c.Nz + 2*HSIZE; std::shared_ptr< tile_type > tile( new tile_type ); for (int z = 0; z < NZ+2*HSIZE; ++z) { for (int y = 0; y < NY+2*HSIZE; ++y) { for (int x = 0; x < NX+2*HSIZE; ++x) { /* set initial values */ float r = fabs((float)( x + tag.x*BSIZEX - Nx/2 + y + tag.y*BSIZEY - Ny/2 + z + tag.z*BSIZEZ - Nz/2) / 30); r = std::max(1 - r, 0.0f) + 1; assert( r != 0.0f ); (*tile)(x-HSIZE,y-HSIZE,z-HSIZE) = r; } } } c.m_tiles.put( tag, std::shared_ptr< const tile_type >( tile ) ); return 0; }
bool GenericCommunicator::RecvThread::recv_msg( int & sender ) { VT_FUNC( "Dist::GenComm::recv_msg" ); // ==> Wait for a client to send a message: // ==> Receive the message from a client: try { serializer * ser = m_channel.waitForAnyClient( sender ); // Check: CNC_ASSERT( 0 <= sender && sender < m_channel.numProcs() ); CNC_ASSERT( sender != m_channel.localId() ); if( ser ) { // Ok, there is body to it, that's why we got the serializer // Call the recv callback of the communicator instance m_instance.recv_msg_callback( *ser, sender ); return false; } else { // ==> termination requested !!! return true; } } catch ( ConnectionError ) { CNC_ABORT( "Connection Error" ); } catch ( ... ) { //throw ClientId( sender ); } return false; }
void GenericCommunicator::recv_msg_callback( serializer & ser, int sender ) { // ITAC logging: VT_RECV( sender, (int)ser.get_total_size(), ITC_TAG_EXTERNAL ); // Prepare the serializer for unpacking: //BufferAccess::initUnpack( ser ); // Delegate the message to the distributor: /* int globalSenderId = sender + m_globalIdShift; uncomment this for the local tests */ { VT_FUNC( "Dist::distributor::recv_msg" ); distributor::recv_msg( &ser/*, globalSenderId uncomment this for the local tests */ ); } }
// ******************************************************************************************* // this is the actual stencil computation // executed once per tile and time-step int stencil_step::execute( const loop_tag & tag, my_context & c ) const { #ifdef CNC_WITH_ITAC VT_FUNC( "RTM::stencil" ); #endif const int NX = tag.x < c.BNX - 1 ? BSIZEX : c.BBSX; const int NY = tag.y < c.BNY - 1 ? BSIZEY : c.BBSY; const int NZ = tag.z < c.BNZ - 1 ? BSIZEZ : c.BBSZ; halo_tile htile; htile.get_tile_and_halo( tag, c.BNX, c.BNY, c.BNZ, NX, NY, NZ, c.m_tiles, c.m_xhalos, c.m_yhalos, c.m_zhalos ); float c0 = c.coeff_x[0], c1 = c.coeff_x[1], c2 = c.coeff_x[2], c3 = c.coeff_x[3], c4 = c.coeff_x[4]; #ifndef VBSZZ # define VBSZZ BSIZEZ #endif CnC::parallel_for( 0, NZ, (const int)VBSZZ, [=]( int bz ) { for( int z = bz; z < NZ && z < bz+VBSZZ; ++z ) { for( int y = 0; y < NY; ++y ) { STENCIL_KERNEL( htile, 0, NX, y, z ); } } }, CnC::pfor_tuner< false >() ); #ifdef DAMPING CnC::parallel_for( 0, NZ, (const int)VBSZZ, [=,&c]( int bz ) { int dampx_beg = 0; int dampx_end = NX; int dampy_beg = 0; int dampy_end = NY; int _start = tag.x * BSIZEX; if( _start < DSIZE ) { dampx_beg = _start + NX >= DSIZE ? DSIZE : NX; for( int z = bz; z < NZ && z < bz+VBSZZ; ++z ) { for( int y = 0; y < NY; ++y ) { STENCIL_KERNEL( htile, 0, dampx_beg, y, z ); } } } int _damp = c.Nx - DSIZE; if( _start + NX > _damp ) { dampx_end = _start < _damp ? _damp - _start : 0; for( int z = bz; z < NZ && z < bz+VBSZZ; ++z ) { for( int y = 0; y < NY; ++y ) { STENCIL_KERNEL( htile, dampx_end, NX, y, z ); } } } _start = tag.y * BSIZEY; if( _start < DSIZE ) { dampy_beg = _start + NY >= DSIZE ? DSIZE : NY; for( int z = bz; z < NZ && z < bz+VBSZZ; ++z ) { for( int y = 0; y < dampy_beg; ++y ) { STENCIL_KERNEL( htile, dampx_beg, dampx_end, y, z ); } } } _damp = c.Ny - DSIZE; if( _start + NY > _damp ) { dampy_end = _start < _damp ? _damp - _start : 0; for( int z = bz; z < NZ && z < bz+VBSZZ; ++z ) { for( int y = dampy_end; y < NY; ++y ) { STENCIL_KERNEL( htile, dampx_beg, dampx_end, y, z ); } } } _start = bz + tag.z * BSIZEZ; if( _start < DSIZE ) { int dampz_beg = _start + NZ >= DSIZE ? DSIZE : NZ; for( int z = bz; z < dampz_beg && z < bz+VBSZZ; ++z ) { for( int y = dampy_beg; y < dampy_end; ++y ) { STENCIL_KERNEL( htile, dampx_beg, dampx_end, y, z ); } } } _damp = c.Nz - DSIZE; if( _start + VBSZZ > _damp ) { int dampz_beg = _start < _damp ? _damp - _start : 0; int dampz_end = _start + VBSZZ >= NX ? NX : _start + VBSZZ; for( int z = dampz_beg; z < dampz_end; ++z ) { for( int y = dampy_beg; y < dampy_end; ++y ) { STENCIL_KERNEL( htile, dampx_beg, dampx_end, y, z ); } } } }, CnC::pfor_tuner< false >() ); #endif // DAMPING htile.put_tile_and_halo( tag, c.BNX, c.BNY, c.BNZ, c.T, NX, NY, NZ, c.m_tiles, c.m_xhalos, c.m_yhalos, c.m_zhalos ); // now let's put the next tag (if not at end of time) int t1 = tag.t + 1; if( t1 < c.T ) { c.m_tags.put( loop_tag( t1, tag.x, tag.y, tag.z ) ); } return 0; }