void ChunkLoaderJob::Execute( void* param /*= 0 */ ) { while( Thread::self()->getCurrentState() != TERMINATED ) { ChunkData to_load( -1, 0, 0 ); int to_load_priority = -1; { MutexLock lock( m_Octree->m_OctreeHandleMutex ); if( m_Octree->m_ChunksToLoad.size() > 0 ) { to_load = m_Octree->m_ChunksToLoad[ 0 ].m_Data; to_load_priority = m_Octree->m_ChunksToLoad[ 0 ].priority; m_Octree->m_CurrentlyLoadingChunkID = to_load.m_ChunkID; m_Octree->m_ChunksToLoad.erase( m_Octree->m_ChunksToLoad.begin() ); } } if( to_load.m_ChunkID > 0 ) { int id = to_load.m_ChunkID; size_t loc = to_load.m_ChunkFilePosition; int size = (int)to_load.m_ChunkSize; m_FileHandle.seekg( loc ); char* chunk_data = reinterpret_cast< char* >( malloc( size ) ); if( chunk_data ) { m_FileHandle.read( chunk_data, size ); { MutexLock lock( m_Octree->m_OctreeHandleMutex ); m_Octree->m_CPU_Allocations += size; m_Octree->m_RawChunkData[ id ] = chunk_data; m_Octree->m_UncheckedDataFromDisk.push_back( ChunkDataPriority( to_load, to_load_priority ) ); m_Octree->m_CurrentlyLoadingChunkID = -1; } } else { MutexLock lock( m_Octree->m_OctreeHandleMutex ); m_Octree->m_ChunksToLoad.push_back( ChunkDataPriority( to_load, to_load_priority ) ); m_Octree->m_NeedsToFreeUnusedChunksFromCPU = true; Sleep( 1 ); } } Sleep( 0 ); } }
void restrictive_coarsening::prepare_data_to_send( int n_local_hyperedges, int n_local_pins, dynamic_array<int> local_hyperedge_weights, dynamic_array<int> local_hyperedge_offsets, dynamic_array<int> local_pins, MPI_Comm comm) { ds::dynamic_array<int> processors(processors_); for (int i = 0; i < processors_; ++i) { processors[i] = i; } ds::dynamic_array<int> min_local_indices(processors_); ds::dynamic_array<int> max_local_indices(processors_); // Prepare data structures MPI_Allgather(&minimum_vertex_index_, 1, MPI_INT, min_local_indices.data(), 1, MPI_INT, comm); MPI_Allgather(&maximum_vertex_index_, 1, MPI_INT, max_local_indices.data(), 1, MPI_INT, comm); ds::complete_binary_tree<int> vertex_to_processor(processors.data(), min_local_indices.data(), processors_); ds::dynamic_array<int> vertices_per_processor(processors_); utility::set_to_zero<int>(vertices_per_processor.data(), processors_); utility::set_to_zero<int>(send_lens_.data(), processors_); ds::bit_field to_load(n_local_hyperedges); if (percentile_ == 100) { to_load.set(); } else { compute_hyperedges_to_load(to_load, n_local_hyperedges, n_local_pins, local_hyperedge_weights, local_hyperedge_offsets, comm); } ds::dynamic_array<bool> sent_to_processor(processors_, false); utility::set_to_zero<int>(send_lens_.data(), processors_); for (int i = 0; i < n_local_hyperedges; ++i) { if (to_load.test(i)) { int start_offset = local_hyperedge_offsets[i]; int end_offset = local_hyperedge_offsets[i + 1]; for (int j = start_offset; j < end_offset; ++j) { int proc = vertex_to_processor.root_value(local_pins[j]); ++vertices_per_processor[proc]; } for (int j = 0; j < processors_; ++j) { if (vertices_per_processor[j] > 1) { if (j == rank_) { hyperedge_weights_[number_of_hyperedges_] = local_hyperedge_weights[i]; hyperedge_offsets_[number_of_hyperedges_] = number_of_local_pins_; ++number_of_hyperedges_; for (int l = start_offset; l < end_offset; ++l) { int local_vertex = local_pins[l] - minimum_vertex_index_; if (0 <= local_vertex && local_vertex < number_of_local_vertices_) { local_pin_list_[number_of_local_pins_++] = local_vertex; ++vertex_to_hyperedges_offset_[local_vertex]; } } } else { data_out_sets_[j][send_lens_[j]++] = vertices_per_processor[j] + 2; data_out_sets_[j][send_lens_[j]++] = local_hyperedge_weights[i]; for (int l = start_offset; l < end_offset; ++l) { if (min_local_indices[j] <= local_pins[l] && local_pins[l] < max_local_indices[j]) { data_out_sets_[j][send_lens_[j]++] = local_pins[l] - min_local_indices[j]; } } } vertices_per_processor[j] = 0; } if (vertices_per_processor[j] == 1) { vertices_per_processor[j] = 0; } } } } }