void Thread::removeOperator(const Operator* op) { typedef std::set< std::vector<Input>::iterator > IndexSet; if (op == 0) throw WrongArgument("Operator must not be null."); m_thread->removeOperator(op); IndexSet toBeErased; for(std::vector<Input>::iterator iter1 = m_inputSequence.begin(); iter1 != m_inputSequence.end(); ++iter1) { if((*iter1).op() == op) toBeErased.insert(iter1); } for(IndexSet::reverse_iterator iter2 = toBeErased.rbegin(); iter2 != toBeErased.rend(); ++iter2) { m_inputSequence.erase(*iter2); } }
IndexSet * mailcore::RangeUnion(Range range1, Range range2) { if (!RangeHasIntersection(range1, range2)) { IndexSet * result = IndexSet::indexSet(); result->addRange(range1); result->addRange(range2); return result; } else { uint64_t left1; uint64_t right1; uint64_t left2; uint64_t right2; uint64_t resultLeft; uint64_t resultRight; left1 = range1.location; right1 = RangeRightBound(range1); left2 = range2.location; right2 = RangeRightBound(range2); resultLeft = MIN(left1, left2); resultRight = MAX(right1, right2); if (resultRight == UINT64_MAX) { return IndexSet::indexSetWithRange(RangeMake(resultLeft, UINT64_MAX)); } else { return IndexSet::indexSetWithRange(RangeMake(resultLeft, resultRight - resultLeft)); } } }
static inline bool are_holes_inside(RingIterator first, RingIterator beyond, ExteriorRing const& exterior_ring, IndexSet const& rings_with_turns) { int idx = 0; for (RingIterator it = first; it != beyond; ++it, ++idx) { // check only rings whose index is not associated to any turn if ( rings_with_turns.find(idx) == rings_with_turns.end() && !geometry::within(range::front(*it), exterior_ring) ) { return false; } } // for those rings that do not have any associated turns, // check if they lie inside another ring idx = 0; for (RingIterator it1 = first; it1 != beyond; ++it1, ++idx) { if ( rings_with_turns.find(idx) == rings_with_turns.end() ) { for (RingIterator it2 = first; it2 != beyond; ++it2) { if ( it1 != it2 && geometry::within(range::front(*it1), *it2) ) { return false; } } } } return true; }
void IndexSet::remove(const IndexSet& s) { if (this == &s) { clear(); return; } if (s.card() == 0) return; if (card() == 0) return; for (long i = s.first(); i <= s.last(); i = s.next(i)) remove(i); // NOTE: traversal order should not matter here }
inline void VectorDBase<T>::assignT(T v, const IndexSet& is) { for (typename IndexSet::Iter i = is.begin(); i != is.end(); ++i) { start[i] = v; } }
bool isDup(const IndexSet& data, const BSONObj& key, RecordId loc) { const IndexSet::const_iterator it = data.find(IndexKeyEntry(key, RecordId())); if (it == data.end()) return false; // Not a dup if the entry is for the same loc. return it->loc != loc; }
// Sanity-check: Check that prime-set is "valid", i.e. that it // contains either all the special primes or none of them bool Ctxt::verifyPrimeSet() const { IndexSet s = primeSet & context.specialPrimes; // special primes in primeSet if (!empty(s) && s!=context.specialPrimes) return false; s = primeSet / s; // ctxt primes in primeSet return (s.isInterval() && s.first()<=1 && !empty(s)); }
void readContextBinary(istream& str, FHEcontext& context) { assert(readEyeCatcher(str, BINIO_EYE_CONTEXT_BEGIN)==0); // Get the standard deviation context.stdev = read_raw_xdouble(str); long sizeOfS = read_raw_int(str); IndexSet s; for(long tmp, i=0; i<sizeOfS; i++){ tmp = read_raw_int(str); s.insert(tmp); } context.moduli.clear(); context.specialPrimes.clear(); context.ctxtPrimes.clear(); long nPrimes = read_raw_int(str); for (long p,i=0; i<nPrimes; i++) { p = read_raw_int(str); context.moduli.push_back(Cmodulus(context.zMStar,p,0)); if (s.contains(i)) context.specialPrimes.insert(i); // special prime else context.ctxtPrimes.insert(i); // ciphertext prime } long nDigits = read_raw_int(str); context.digits.resize(nDigits); for(long i=0; i<(long)context.digits.size(); i++){ sizeOfS = read_raw_int(str); for(long tmp, n=0; n<sizeOfS; n++){ tmp = read_raw_int(str); context.digits[i].insert(tmp); } } // Read in the partition of m into co-prime factors (if bootstrappable) Vec<long> mv; read_ntl_vec_long(str, mv); long t = read_raw_int(str); bool consFlag = read_raw_int(str); if (mv.length()>0) { context.makeBootstrappable(mv, t, consFlag); } assert(readEyeCatcher(str, BINIO_EYE_CONTEXT_END)==0); }
void IndexSet::retain(const IndexSet& s) { if (this == &s) return; if (s.card() == 0) { clear(); return; } if (card() == 0) return; for (long i = first(); i <= last(); i = next(i)) { if (!s.contains(i)) remove(i); } }
bool isDup(const IndexSet& data, const BSONObj& key) { IndexSet::const_iterator it = data.find(IndexKeyEntry(key, RecordId())); if (it == data.end()) return false; ++it; if (it == data.end()) return false; return it->key.woCompare(key, BSONObj(), false) == 0; }
inline void VectorDBase<T>::assign(const VectorDBase<T>& v1, const IndexSet& is) { assert(v1.get_size() == is.get_size()); assert(get_size() == is.count()); T* i = start; for (typename IndexSet::Iter i1 = is.begin(); i1 != is.end(); ++i1) { *i = v1[i1]; ++i; } }
//! @brief How many levels in the "base-set" for that ciphertext long Ctxt::findBaseLevel() const { IndexSet s; findBaseSet(s); if (context.containsSmallPrime()) { if (s.contains(context.ctxtPrimes.first())) return 2*card(s) -1; // 1st prime is half size else return 2*card(s); } else return card(s); // one prime per level }
void LocalViewSelection::replaceViews(IndexSet const & toBeReplaced) { IndexSet::const_iterator tbr = toBeReplaced.begin(); while (tbr != toBeReplaced.end()) { available[*tbr] = false; selected.erase(*tbr); ++tbr; } success = false; performVS(); }
// Find the IndexSet such that modDown to that set of primes makes the // additive term due to rounding into the dominant noise term void Ctxt::findBaseSet(IndexSet& s) const { if (getNoiseVar()<=0.0) { // an empty ciphertext s = context.ctxtPrimes; return; } assert(verifyPrimeSet()); bool halfSize = context.containsSmallPrime(); double curNoise = log(getNoiseVar())/2; double firstNoise = context.logOfPrime(0); double noiseThreshold = log(modSwitchAddedNoiseVar())*0.55; // FIXME: The above should have been 0.5. Making it a bit more means // that we will mod-switch a little less frequently, whether this is // a good thing needs to be tested. // remove special primes, if they are included in this->primeSet s = getPrimeSet(); if (!s.disjointFrom(context.specialPrimes)) { // scale down noise curNoise -= context.logOfProduct(context.specialPrimes); s.remove(context.specialPrimes); } /* We compare below to noiseThreshold+1 rather than to noiseThreshold * to make sure that if you mod-switch down to c.findBaseSet() and * then immediately call c.findBaseSet() again, it will not tell you * to mod-switch further down. Note that mod-switching adds close to * noiseThreshold to the scaled noise, so if the scaled noise was * equal to noiseThreshold then after mod-switchign you would have * roughly twice as much noise. Since we're mesuring the log, it means * that you may have as much as noiseThreshold+log(2), which we round * up to noiseThreshold+1 in the test below. */ if (curNoise<=noiseThreshold+1) return; // no need to mod down // if the first prime in half size, begin by removing it if (halfSize && s.contains(0)) { curNoise -= firstNoise; s.remove(0); } // while noise is larger than threshold, scale down by the next prime while (curNoise>noiseThreshold && !empty(s)) { curNoise -= context.logOfPrime(s.last()); s.remove(s.last()); } // Add 1st prime if s is empty or if this does not increase noise too much if (empty(s) || (!s.contains(0) && curNoise+firstNoise<=noiseThreshold)) { s.insert(0); curNoise += firstNoise; } if (curNoise>noiseThreshold && log_of_ratio()>-0.5) cerr << "Ctxt::findBaseSet warning: already at lowest level\n"; }
//------------------------------add_liveout------------------------------------ // Add a live-out value to a given blocks live-out set. If it is new, then // also add it to the delta set and stick the block on the worklist. void PhaseLive::add_liveout( Block *p, uint r, VectorSet &first_pass ) { IndexSet *live = &_live[p->_pre_order-1]; if( live->insert(r) ) { // If actually inserted... // We extended the live-out set. See if the value is generated locally. // If it is not, then we must extend the live-in set. if( !_defs[p->_pre_order-1].member( r ) ) { if( !_deltas[p->_pre_order-1] && // Not on worklist? first_pass.test(p->_pre_order) ) _worklist->push(p); // Actually go on worklist if already 1st pass getset(p)->insert(r); } } }
//------------------------------Union------------------------------------------ // Union edges of B into A void PhaseIFG::Union( uint a, uint b ) { assert( _is_square, "only on square" ); IndexSet *A = &_adjs[a]; IndexSetIterator b_elements(&_adjs[b]); uint datum; while ((datum = b_elements.next()) != 0) { if(A->insert(datum)) { _adjs[datum].insert(a); lrgs(a).invalid_degree(); lrgs(datum).invalid_degree(); } } }
void IndexSet::insert(const IndexSet& s) { if (this == &s) return; if (s.card() == 0) return; if (card() == 0) { *this = s; return; } for (long i = s.last(); i >= s.first(); i = s.prev(i)) insert(i); // NOTE: traversal done from high to low so as to trigger at // at most one resize }
DoubleCRT::DoubleCRT(const ZZX& poly, const FHEcontext &_context, const IndexSet& s) : context(_context), map(new DoubleCRTHelper(_context)) { assert(s.last() < context.numPrimes()); map.insert(s); if (dryRun) return; // convert the integer polynomial to FFT representation modulo the primes for (long i = s.first(); i <= s.last(); i = s.next(i)) { const Cmodulus &pi = context.ithModulus(i); pi.FFT(map[i], poly); // reduce mod pi and store FFT image } }
DoubleCRT::DoubleCRT(const FHEcontext &_context, const IndexSet& s) : context(_context), map(new DoubleCRTHelper(_context)) { assert(s.last() < context.numPrimes()); map.insert(s); if (dryRun) return; long phim = context.zMStar.getPhiM(); for (long i = s.first(); i <= s.last(); i = s.next(i)) { vec_long& row = map[i]; for (long j = 0; j < phim; j++) row[j] = 0; } }
DoubleCRT::DoubleCRT(const ZZX& poly) : context(*activeContext), map(new DoubleCRTHelper(*activeContext)) { IndexSet s = IndexSet(0, context.numPrimes()-1); // FIXME: maybe the default index set should be determined by context? map.insert(s); if (dryRun) return; // convert the integer polynomial to FFT representation modulo the primes for (long i = s.first(); i <= s.last(); i = s.next(i)) { const Cmodulus &pi = context.ithModulus(i); pi.FFT(map[i], poly); // reduce mod pi and store FFT image } }
//------------------------------getfreeset------------------------------------- // Pull from free list, or allocate. Internal allocation on the returned set // is always from thread local storage. IndexSet *PhaseLive::getfreeset( ) { IndexSet *f = _free_IndexSet; if( !f ) { f = new IndexSet; // f->set_arena(Thread::current()->resource_area()); f->initialize(_maxlrg, Thread::current()->resource_area()); } else { // Pull from free list _free_IndexSet = f->next(); //f->_cnt = 0; // Reset to empty // f->set_arena(Thread::current()->resource_area()); f->initialize(_maxlrg, Thread::current()->resource_area()); } return f; }
inline void FullTree<IndexSet>::insert(const IndexSet& support, int index) { IndexSet empty(support.get_size(),0); root.insert(support, empty, index); }
DoubleCRT::DoubleCRT(const FHEcontext &_context) : context(_context), map(new DoubleCRTHelper(_context)) { IndexSet s = IndexSet(0, context.numPrimes()-1); // FIXME: maybe the default index set should be determined by context? map.insert(s); if (dryRun) return; long phim = context.zMStar.getPhiM(); for (long i = s.first(); i <= s.last(); i = s.next(i)) { vec_long& row = map[i]; for (long j = 0; j < phim; j++) row[j] = 0; } }
inline void BinaryTree<IndexSet>::insert(const IndexSet& support, Index index) { supp_size = support.get_size(); root = root->insert(support, index); }
// expand index set by s1. // it is assumed that s1 is disjoint from the current index set. void DoubleCRT::addPrimes(const IndexSet& s1) { if (empty(s1)) return; // nothing to do assert( disjoint(s1,map.getIndexSet()) ); // s1 is disjoint from *this ZZX poly; toPoly(poly); // recover in coefficient representation map.insert(s1); // add new rows to the map if (dryRun) return; // fill in new rows for (long i = s1.first(); i <= s1.last(); i = s1.next(i)) { context.ithModulus(i).FFT(map[i], poly); // reduce mod p_i and store FFT image } }
void readIndexSetFromFile(IndexSet<Index2D> &Lambda, string filename) { std::ifstream infile (filename.c_str()); if (infile.is_open()) { cerr << " Indexset file is open." << endl; } else { cerr << " Indexset file " << filename.c_str() << " is not open." << endl; } int t1,t2; int j1,j2; long k1,k2; T coeff; while(!infile.eof()) { infile >> t1 >> j1 >> k1 >> t2 >> j2 >> k2 >> coeff; if (t1 == 1 && t2 == 1) { Index1D index_x(j1,k1,XWavelet); Index1D index_y(j2,k2,XWavelet); Lambda.insert(Index2D(index_x,index_y)); } else if (t1 == 1 && t2 == 0) { Index1D index_x(j1,k1,XWavelet); Index1D index_y(j2,k2,XBSpline); Lambda.insert(Index2D(index_x,index_y)); } else if (t1 == 0 && t2 == 1) { Index1D index_x(j1,k1,XBSpline); Index1D index_y(j2,k2,XWavelet); Lambda.insert(Index2D(index_x,index_y)); } else if (t1 == 0 && t2 == 0) { Index1D index_x(j1,k1,XBSpline); Index1D index_y(j2,k2,XBSpline); Lambda.insert(Index2D(index_x,index_y)); } else { std::cerr << "Could not read file." << std::endl; exit(1); return; } } }
SingleCRT::SingleCRT(const ZZX&poly, const FHEcontext& _context, const IndexSet& s) : context(_context) { assert(s.last() < context.numPrimes()); map.insert(s); *this = poly; // convert polynomial to singleCRT representation }
// Without specifying a ZZX, we get the zero polynomial SingleCRT::SingleCRT(const FHEcontext &_context, const IndexSet& s) : context(_context) { assert(s.last() < context.numPrimes()); map.insert(s); // default constructor for ZZX creates the zero polynomial }
NTL_CLIENT #include "FHEContext.h" #include "Ctxt.h" #include "FHE.h" #include "timing.h" // Sanity-check: Check that prime-set is "valid", i.e. that it // contains either all the special primes or none of them bool Ctxt::verifyPrimeSet() const { IndexSet s = primeSet & context.specialPrimes; // special primes in primeSet if (!empty(s) && s!=context.specialPrimes) return false; s = primeSet / s; // ctxt primes in primeSet return (s.isInterval() && s.first()<=1 && !empty(s)); }
void Procedure::deleteOrphans() { IndexSet<Value> valuesInBlocks; for (BasicBlock* block : *this) valuesInBlocks.addAll(*block); // Since this method is not on any hot path, we do it conservatively: first a pass to // identify the values to be removed, and then a second pass to remove them. This avoids any // risk of the value iteration being broken by removals. Vector<Value*, 16> toRemove; for (Value* value : values()) { if (!valuesInBlocks.contains(value)) toRemove.append(value); } for (Value* value : toRemove) deleteValue(value); }