From 0656fb649a05da91d4e8edab6e1abbcfdb2f4f75 Mon Sep 17 00:00:00 2001 From: Arnaud Giersch Date: Thu, 11 Jul 2019 16:11:45 +0200 Subject: [PATCH] mc/compare: factorize code. --- src/mc/compare.cpp | 110 +++++++++++++++++++-------------------------- 1 file changed, 47 insertions(+), 63 deletions(-) diff --git a/src/mc/compare.cpp b/src/mc/compare.cpp index 4cbb1b891b..b913fae342 100644 --- a/src/mc/compare.cpp +++ b/src/mc/compare.cpp @@ -82,38 +82,22 @@ public: std::vector* i1, std::vector* i2); - HeapArea& equals_to1_(std::size_t i, std::size_t j) + template HeapArea& equals_to_(std::size_t i, std::size_t j) { - return processStates[0].equals_to[ MAX_FRAGMENT_PER_BLOCK * i + j]; + return processStates[rank - 1].equals_to[MAX_FRAGMENT_PER_BLOCK * i + j]; } - HeapArea& equals_to2_(std::size_t i, std::size_t j) + template Type*& types_(std::size_t i, std::size_t j) { - return processStates[1].equals_to[ MAX_FRAGMENT_PER_BLOCK * i + j]; - } - Type*& types1_(std::size_t i, std::size_t j) - { - return processStates[0].types[ MAX_FRAGMENT_PER_BLOCK * i + j]; - } - Type*& types2_(std::size_t i, std::size_t j) - { - return processStates[1].types[ MAX_FRAGMENT_PER_BLOCK * i + j]; + return processStates[rank - 1].types[MAX_FRAGMENT_PER_BLOCK * i + j]; } - HeapArea const& equals_to1_(std::size_t i, std::size_t j) const - { - return processStates[0].equals_to[ MAX_FRAGMENT_PER_BLOCK * i + j]; - } - HeapArea const& equals_to2_(std::size_t i, std::size_t j) const - { - return processStates[1].equals_to[ MAX_FRAGMENT_PER_BLOCK * i + j]; - } - Type* const& types1_(std::size_t i, std::size_t j) const + template HeapArea const& equals_to_(std::size_t i, std::size_t j) const { - return processStates[0].types[ MAX_FRAGMENT_PER_BLOCK * i + j]; + return processStates[rank - 1].equals_to[MAX_FRAGMENT_PER_BLOCK * i + j]; } - Type* const& types2_(std::size_t i, std::size_t j) const + template Type* const& types_(std::size_t i, std::size_t j) const { - return processStates[1].types[ MAX_FRAGMENT_PER_BLOCK * i + j]; + return processStates[rank - 1].types[MAX_FRAGMENT_PER_BLOCK * i + j]; } /** Check whether two blocks are known to be matching @@ -124,7 +108,7 @@ public: */ bool blocksEqual(int b1, int b2) const { - return this->equals_to1_(b1, 0).block_ == b2 && this->equals_to2_(b2, 0).block_ == b1; + return this->equals_to_<1>(b1, 0).block_ == b2 && this->equals_to_<2>(b2, 0).block_ == b1; } /** Check whether two fragments are known to be matching @@ -137,8 +121,8 @@ public: */ int fragmentsEqual(int b1, int f1, int b2, int f2) const { - return this->equals_to1_(b1, f1).block_ == b2 && this->equals_to1_(b1, f1).fragment_ == f2 && - this->equals_to2_(b2, f2).block_ == b1 && this->equals_to2_(b2, f2).fragment_ == f1; + return this->equals_to_<1>(b1, f1).block_ == b2 && this->equals_to_<1>(b1, f1).fragment_ == f2 && + this->equals_to_<2>(b2, f2).block_ == b1 && this->equals_to_<2>(b2, f2).fragment_ == f1; } void match_equals(HeapLocationPairs* list); @@ -200,11 +184,11 @@ void StateComparator::match_equals(HeapLocationPairs* list) { for (auto const& pair : *list) { if (pair[0].fragment_ != -1) { - this->equals_to1_(pair[0].block_, pair[0].fragment_) = simgrid::mc::HeapArea(pair[1].block_, pair[1].fragment_); - this->equals_to2_(pair[1].block_, pair[1].fragment_) = simgrid::mc::HeapArea(pair[0].block_, pair[0].fragment_); + this->equals_to_<1>(pair[0].block_, pair[0].fragment_) = simgrid::mc::HeapArea(pair[1].block_, pair[1].fragment_); + this->equals_to_<2>(pair[1].block_, pair[1].fragment_) = simgrid::mc::HeapArea(pair[0].block_, pair[0].fragment_); } else { - this->equals_to1_(pair[0].block_, 0) = simgrid::mc::HeapArea(pair[1].block_, pair[1].fragment_); - this->equals_to2_(pair[1].block_, 0) = simgrid::mc::HeapArea(pair[0].block_, pair[0].fragment_); + this->equals_to_<1>(pair[0].block_, 0) = simgrid::mc::HeapArea(pair[1].block_, pair[1].fragment_); + this->equals_to_<2>(pair[1].block_, 0) = simgrid::mc::HeapArea(pair[0].block_, pair[0].fragment_); } } } @@ -291,14 +275,14 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc if (is_stack(addr_block1)) { for (size_t k = 0; k < heapinfo1->busy_block.size; k++) - state.equals_to1_(i1 + k, 0) = HeapArea(i1, -1); + state.equals_to_<1>(i1 + k, 0) = HeapArea(i1, -1); for (size_t k = 0; k < heapinfo2->busy_block.size; k++) - state.equals_to2_(i1 + k, 0) = HeapArea(i1, -1); + state.equals_to_<2>(i1 + k, 0) = HeapArea(i1, -1); i1 += heapinfo1->busy_block.size; continue; } - if (state.equals_to1_(i1, 0).valid_) { + if (state.equals_to_<1>(i1, 0).valid_) { i1++; continue; } @@ -307,13 +291,13 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc bool equal = false; /* Try first to associate to same block in the other heap */ - if (heapinfo2->type == heapinfo1->type && state.equals_to2_(i1, 0).valid_ == 0) { + if (heapinfo2->type == heapinfo1->type && state.equals_to_<2>(i1, 0).valid_ == 0) { void* addr_block2 = (ADDR2UINT(i1) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase; if (not heap_area_differ(state, addr_block1, addr_block2, snapshot1, snapshot2, nullptr, nullptr, 0)) { for (size_t k = 1; k < heapinfo2->busy_block.size; k++) - state.equals_to2_(i1 + k, 0) = HeapArea(i1, -1); + state.equals_to_<2>(i1 + k, 0) = HeapArea(i1, -1); for (size_t k = 1; k < heapinfo1->busy_block.size; k++) - state.equals_to1_(i1 + k, 0) = HeapArea(i1, -1); + state.equals_to_<1>(i1 + k, 0) = HeapArea(i1, -1); equal = true; i1 += heapinfo1->busy_block.size; } @@ -336,16 +320,16 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc continue; } - if (state.equals_to2_(i2, 0).valid_) { + if (state.equals_to_<2>(i2, 0).valid_) { i2++; continue; } if (not heap_area_differ(state, addr_block1, addr_block2, snapshot1, snapshot2, nullptr, nullptr, 0)) { for (size_t k = 1; k < heapinfo2b->busy_block.size; k++) - state.equals_to2_(i2 + k, 0) = HeapArea(i1, -1); + state.equals_to_<2>(i2 + k, 0) = HeapArea(i1, -1); for (size_t k = 1; k < heapinfo1->busy_block.size; k++) - state.equals_to1_(i1 + k, 0) = HeapArea(i2, -1); + state.equals_to_<1>(i1 + k, 0) = HeapArea(i2, -1); equal = true; i1 += heapinfo1->busy_block.size; } @@ -365,7 +349,7 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc if (heapinfo1->busy_frag.frag_size[j1] == -1) /* Free fragment_ */ continue; - if (state.equals_to1_(i1, j1).valid_) + if (state.equals_to_<1>(i1, j1).valid_) continue; void* addr_frag1 = (void*)((char*)addr_block1 + (j1 << heapinfo1->type)); @@ -374,7 +358,7 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc bool equal = false; /* Try first to associate to same fragment_ in the other heap */ - if (heapinfo2->type == heapinfo1->type && not state.equals_to2_(i1, j1).valid_) { + if (heapinfo2->type == heapinfo1->type && not state.equals_to_<2>(i1, j1).valid_) { void* addr_block2 = (ADDR2UINT(i1) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase; void* addr_frag2 = (void*)((char*)addr_block2 + (j1 << heapinfo2->type)); if (not heap_area_differ(state, addr_frag1, addr_frag2, snapshot1, snapshot2, nullptr, nullptr, 0)) @@ -407,7 +391,7 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc if (i2 == i1 && j2 == j1) continue; - if (state.equals_to2_(i2, j2).valid_) + if (state.equals_to_<2>(i2, j2).valid_) continue; void* addr_block2 = (ADDR2UINT(i2) - 1) * BLOCKSIZE + (char*)state.std_heap_copy.heapbase; @@ -439,7 +423,7 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc (const malloc_info*)heap_region1->read(&heapinfo_temp1, &heapinfos1[i], sizeof(malloc_info)); if (heapinfo1->type == MMALLOC_TYPE_UNFRAGMENTED && i1 == state.heaplimit && heapinfo1->busy_block.busy_size > 0 && - not state.equals_to1_(i, 0).valid_) { + not state.equals_to_<1>(i, 0).valid_) { XBT_DEBUG("Block %zu not found (size used = %zu)", i, heapinfo1->busy_block.busy_size); return true; } @@ -447,7 +431,7 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc if (heapinfo1->type <= 0) continue; for (size_t j = 0; j < (size_t)(BLOCKSIZE >> heapinfo1->type); j++) - if (i1 == state.heaplimit && heapinfo1->busy_frag.frag_size[j] > 0 && not state.equals_to1_(i, j).valid_) { + if (i1 == state.heaplimit && heapinfo1->busy_frag.frag_size[j] > 0 && not state.equals_to_<1>(i, j).valid_) { XBT_DEBUG("Block %zu, Fragment %zu not found (size used = %zd)", i, j, heapinfo1->busy_frag.frag_size[j]); return true; } @@ -457,7 +441,7 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc const malloc_info* heapinfo2 = (const malloc_info*)heap_region2->read(&heapinfo_temp2, &heapinfos2[i], sizeof(malloc_info)); if (heapinfo2->type == MMALLOC_TYPE_UNFRAGMENTED && i1 == state.heaplimit && heapinfo2->busy_block.busy_size > 0 && - not state.equals_to2_(i, 0).valid_) { + not state.equals_to_<2>(i, 0).valid_) { XBT_DEBUG("Block %zu not found (size used = %zu)", i, heapinfo2->busy_block.busy_size); return true; @@ -467,7 +451,7 @@ static bool mmalloc_heap_differ(simgrid::mc::StateComparator& state, simgrid::mc continue; for (size_t j = 0; j < (size_t)(BLOCKSIZE >> heapinfo2->type); j++) - if (i1 == state.heaplimit && heapinfo2->busy_frag.frag_size[j] > 0 && not state.equals_to2_(i, j).valid_) { + if (i1 == state.heaplimit && heapinfo2->busy_frag.frag_size[j] > 0 && not state.equals_to_<2>(i, j).valid_) { XBT_DEBUG("Block %zu, Fragment %zu not found (size used = %zd)", i, j, heapinfo2->busy_frag.frag_size[j]); return true; @@ -887,7 +871,7 @@ static bool heap_area_differ(simgrid::mc::StateComparator& state, const void* ar // TODO, lookup variable type from block type as done for fragmented blocks - if (state.equals_to1_(block1, 0).valid_ && state.equals_to2_(block2, 0).valid_ && + if (state.equals_to_<1>(block1, 0).valid_ && state.equals_to_<2>(block2, 0).valid_ && state.blocksEqual(block1, block2)) { if (match_pairs) state.match_equals(previous); @@ -917,9 +901,9 @@ static bool heap_area_differ(simgrid::mc::StateComparator& state, const void* ar // Remember (basic) type inference. // The current data structure only allows us to do this for the whole block. if (type != nullptr && area1 == real_addr_block1) - state.types1_(block1, 0) = type; + state.types_<1>(block1, 0) = type; if (type != nullptr && area2 == real_addr_block2) - state.types2_(block2, 0) = type; + state.types_<2>(block2, 0) = type; if (size <= 0) { if (match_pairs) @@ -958,7 +942,7 @@ static bool heap_area_differ(simgrid::mc::StateComparator& state, const void* ar } // Check if the blocks are already matched together: - if (state.equals_to1_(block1, frag1).valid_ && state.equals_to2_(block2, frag2).valid_ && offset1 == offset2 && + if (state.equals_to_<1>(block1, frag1).valid_ && state.equals_to_<2>(block2, frag2).valid_ && offset1 == offset2 && state.fragmentsEqual(block1, frag1, block2, frag2)) { if (match_pairs) state.match_equals(previous); @@ -980,29 +964,29 @@ static bool heap_area_differ(simgrid::mc::StateComparator& state, const void* ar // Remember (basic) type inference. // The current data structure only allows us to do this for the whole fragment_. if (type != nullptr && area1 == real_addr_frag1) - state.types1_(block1, frag1) = type; + state.types_<1>(block1, frag1) = type; if (type != nullptr && area2 == real_addr_frag2) - state.types2_(block2, frag2) = type; + state.types_<2>(block2, frag2) = type; // The type of the variable is already known: if (type) { new_type1 = new_type2 = type; } // Type inference from the block type. - else if (state.types1_(block1, frag1) != nullptr || state.types2_(block2, frag2) != nullptr) { + else if (state.types_<1>(block1, frag1) != nullptr || state.types_<2>(block2, frag2) != nullptr) { offset1 = (char*)area1 - (char*)real_addr_frag1; offset2 = (char*)area2 - (char*)real_addr_frag2; - if (state.types1_(block1, frag1) != nullptr && state.types2_(block2, frag2) != nullptr) { - new_type1 = get_offset_type(real_addr_frag1, state.types1_(block1, frag1), offset1, size, snapshot1); - new_type2 = get_offset_type(real_addr_frag2, state.types2_(block2, frag2), offset1, size, snapshot2); - } else if (state.types1_(block1, frag1) != nullptr) { - new_type1 = get_offset_type(real_addr_frag1, state.types1_(block1, frag1), offset1, size, snapshot1); - new_type2 = get_offset_type(real_addr_frag2, state.types1_(block1, frag1), offset2, size, snapshot2); - } else if (state.types2_(block2, frag2) != nullptr) { - new_type1 = get_offset_type(real_addr_frag1, state.types2_(block2, frag2), offset1, size, snapshot1); - new_type2 = get_offset_type(real_addr_frag2, state.types2_(block2, frag2), offset2, size, snapshot2); + if (state.types_<1>(block1, frag1) != nullptr && state.types_<2>(block2, frag2) != nullptr) { + new_type1 = get_offset_type(real_addr_frag1, state.types_<1>(block1, frag1), offset1, size, snapshot1); + new_type2 = get_offset_type(real_addr_frag2, state.types_<2>(block2, frag2), offset1, size, snapshot2); + } else if (state.types_<1>(block1, frag1) != nullptr) { + new_type1 = get_offset_type(real_addr_frag1, state.types_<1>(block1, frag1), offset1, size, snapshot1); + new_type2 = get_offset_type(real_addr_frag2, state.types_<1>(block1, frag1), offset2, size, snapshot2); + } else if (state.types_<2>(block2, frag2) != nullptr) { + new_type1 = get_offset_type(real_addr_frag1, state.types_<2>(block2, frag2), offset1, size, snapshot1); + new_type2 = get_offset_type(real_addr_frag2, state.types_<2>(block2, frag2), offset2, size, snapshot2); } else { if (match_pairs) state.match_equals(previous); -- 2.20.1