void RandomSet::remove(int element) { boost::unordered_set<int>::iterator set_it = this->element_set.find(element); if(set_it != this->element_set.end()) { this->element_set.erase(set_it); std::vector<int>::iterator it = iterator_to(element); if(it != this->elements.end()) { this->elements.erase(it); } } }
void MethodTransform::inline_tail_call(DexMethod* caller, DexMethod* callee, DexInstruction* invoke) { TRACE(INL, 2, "caller: %s\ncallee: %s\n", SHOW(caller), SHOW(callee)); MethodTransformer tcaller(caller); MethodTransformer tcallee(callee); auto fcaller = tcaller->m_fmethod; auto fcallee = tcallee->m_fmethod; auto bregs = caller->get_code()->get_registers_size(); auto eregs = callee->get_code()->get_registers_size(); auto bins = caller->get_code()->get_ins_size(); auto eins = callee->get_code()->get_ins_size(); always_assert(bins >= eins); auto newregs = std::max(bregs, uint16_t(eregs + bins - eins)); always_assert(newregs <= 16); // Remap registers to account for possibly larger frame, more ins remap_caller_regs(caller, fcaller, newregs); remap_callee_regs(invoke, callee, fcallee, newregs); callee->get_code()->set_ins_size(bins); auto pos = std::find_if(fcaller->begin(), fcaller->end(), [invoke](const MethodItemEntry& mei) { return mei.type == MFLOW_OPCODE && mei.insn == invoke; }); cleanup_callee_debug(fcallee); auto it = fcallee->begin(); while (it != fcallee->end()) { auto& mei = *it++; fcallee->erase(fcallee->iterator_to(mei)); fcaller->insert(pos, mei); } // Delete the vestigial tail. while (pos != fcaller->end()) { if (pos->type == MFLOW_OPCODE) { pos = fcaller->erase_and_dispose(pos, FatMethodDisposer()); } else { ++pos; } } caller->get_code()->set_outs_size(callee->get_code()->get_outs_size()); }
bool DynamicPersistenceTrails<D,CT,OT,E,Cmp,CCmp>:: transpose(iterator i, const DimensionFunctor& dimension, Visitor visitor) { #if LOGGING typename Traits::OutputMap outmap(order()); #endif Count(cTransposition); typedef typename Element::Trail::iterator TrailIterator; visitor.transpose(i); iterator i_prev = i++; if (dimension(i_prev) != dimension(i)) { swap(i_prev, i); rLog(rlTranspositions, "Different dimension"); Count(cTranspositionDiffDim); return false; } bool si = i_prev->sign(), sii = i->sign(); if (si && sii) { rLog(rlTranspositions, "Trail prev: %s", i_prev->trail.tostring(outmap).c_str()); // Case 1 if (trail_remove_if_contains(i_prev, index(i))) rLog(rlTranspositions, "Case 1, U[i,i+1] = 1"); iterator k = iterator_to(i_prev->pair); iterator l = iterator_to(i->pair); // rLog(rlTranspositions, "(i_prev, k), (i, l): (%s, %s), (%s, %s)", // outmap(i_prev).c_str(), outmap(k).c_str(), // outmap(i).c_str(), outmap(l).c_str()); // Explicit treatment of unpaired simplex if (l == i) { swap(i_prev, i); rLog(rlTranspositions, "Case 1.2 --- unpaired"); rLog(rlTranspositions, "%s", outmap(i_prev).c_str()); Count(cTranspositionCase12); return false; } else if (k == i_prev) { if (!(l->cycle.contains(index(i_prev)))) { // Case 1.2 swap(i_prev, i); rLog(rlTranspositions, "Case 1.2 --- unpaired"); rLog(rlTranspositions, outmap(i_prev).c_str()); Count(cTranspositionCase12); return false; } else { // Case 1.2 --- special version (plain swap, but pairing switches) swap(i_prev, i); pairing_switch(i_prev, i); visitor.switched(i, Case12); rLog(rlTranspositions, "Case 1.2 --- unpaired (pairing switch)"); rLog(rlTranspositions, outmap(i_prev).c_str()); Count(cTranspositionCase12s); return true; } } rLog(rlTranspositions, "l cycle: %s", l->cycle.tostring(outmap).c_str()); if (!(l->cycle.contains(index(i_prev)))) { // Case 1.2 rLog(rlTranspositions, "k is in l: %d", (bool) l->trail.contains(index(k))); // if true, a special update would be needed to maintain lazy decomposition swap(i_prev, i); rLog(rlTranspositions, "Case 1.2"); Count(cTranspositionCase12); return false; } else { // Case 1.1 if (std::not2(order_comparison())(index(k),index(l))) { // Case 1.1.1 swap(i_prev, i); cycle_add(l, k->cycle); // Add column k to l trail_add(k, l->trail); // Add row l to k rLog(rlTranspositions, "Case 1.1.1"); Count(cTranspositionCase111); return false; } else { // Case 1.1.2 swap(i_prev, i); cycle_add(k, l->cycle); // Add column l to k trail_add(l, k->trail); // Add row k to l pairing_switch(i_prev, i); visitor.switched(i, Case112); rLog(rlTranspositions, "Case 1.1.2"); Count(cTranspositionCase112); return true; } } } else if (!si && !sii) { // Case 2 if (!(i_prev->trail.contains(index(i)))) { // Case 2.2 swap(i_prev, i); rLog(rlTranspositions, "Case 2.2"); Count(cTranspositionCase22); return false; } else { // Case 2.1 iterator low_i = iterator_to(i_prev->pair); iterator low_ii = iterator_to(i->pair); trail_add(i_prev, i->trail); // Add row i to i_prev cycle_add(i, i_prev->cycle); // Add column i_prev to i swap(i_prev, i); if (std::not2(order_comparison())(index(low_ii), index(low_i))) { // Case 2.1.2 cycle_add(i_prev, i->cycle); // Add column i to i_prev (after transposition) trail_add(i, i_prev->trail); // Add row i to i_prev pairing_switch(i_prev, i); visitor.switched(i, Case212); rLog(rlTranspositions, "Case 2.1.2"); Count(cTranspositionCase212); return true; } // Case 2.1.1 rLog(rlTranspositions, "Case 2.1.1"); Count(cTranspositionCase211); return false; } } else if (!si && sii) { // Case 3 if (!(i_prev->trail.contains(index(i)))) { // Case 3.2 swap(i_prev, i); rLog(rlTranspositions, "Case 3.2"); Count(cTranspositionCase32); return false; } else { // Case 3.1 trail_add(i_prev, i->trail); // Add row i to i_prev cycle_add(i, i_prev->cycle); // Add column i_prev to i swap(i_prev, i); cycle_add(i_prev, i->cycle); // Add column i_prev to i (after transposition) trail_add(i, i_prev->trail); // Add row i to i_prev pairing_switch(i_prev, i); visitor.switched(i, Case31); rLog(rlTranspositions, "Case 3.1"); Count(cTranspositionCase31); return true; } } else if (si && !sii) { // Case 4 if (trail_remove_if_contains(i_prev, index(i))) rLog(rlTranspositions, "Case 4, U[i,i+1] = 1"); swap(i_prev, i); rLog(rlTranspositions, "Case 4"); Count(cTranspositionCase4); return false; } return false; // to avoid compiler complaints; we should never reach this point }
IRList::difference_type IRList::index_of(const MethodItemEntry& mie) const { return std::distance(iterator_to(mie), begin()); }
void StaticPersistence<D, CT, OT, E, Cmp>:: pair_simplices(iterator bg, iterator end, bool store_negative, const Visitor& visitor) { #if LOGGING typename ContainerTraits::OutputMap outmap(order_); #endif // FIXME: need sane output for logging rLog(rlPersistence, "Entered: pair_simplices"); for (iterator j = bg; j != end; ++j) { visitor.init(j); rLog(rlPersistence, "Simplex %s", outmap(j).c_str()); Cycle z; swap_cycle(j, z); rLog(rlPersistence, " has boundary: %s", z.tostring(outmap).c_str()); // Sparsify the cycle by removing the negative elements if (!store_negative) { typename OrderElement::Cycle zz; BOOST_FOREACH(OrderIndex i, z) if (i->sign()) // positive zz.push_back(i); z.swap(zz); } // -------------------------- CountNum(cPersistencePairBoundaries, z.size()); #ifdef COUNTERS Count(cPersistencePair); #endif // COUNTERS while(!z.empty()) { OrderIndex i = z.top(ocmp_); // take the youngest element with respect to the OrderComparison rLog(rlPersistence, " %s: %s", outmap(i).c_str(), outmap(i->pair).c_str()); // TODO: is this even a meaningful assert? AssertMsg(!ocmp_(i, index(j)), "Simplices in the cycle must precede current simplex: (%s in cycle of %s)", outmap(i).c_str(), outmap(j).c_str()); // i is not paired, so we pair j with i if (iterator_to(i->pair) == iterator_to(i)) { rLog(rlPersistence, " Pairing %s and %s with cycle %s", outmap(i).c_str(), outmap(j).c_str(), z.tostring(outmap).c_str()); set_pair(i, j); swap_cycle(j, z); set_pair(j, i); CountNum(cPersistencePairCycleLength, j->cycle.size()); CountBy (cPersistencePairCycleLength, j->cycle.size()); break; } // update element z.add(i->pair->cycle, ocmp_); visitor.update(j, iterator_to(i)); rLog(rlPersistence, " new cycle: %s", z.tostring(outmap).c_str()); } // if z was empty, so is (already) j->cycle, so nothing to do visitor.finished(j); rLog(rlPersistence, "Finished with %s: %s", outmap(j).c_str(), outmap(j->pair).c_str()); }