void insert(const cache_key_type &key, const cache_value_type &val) { // Record k as most-recently-used key list_iterator it = list_.insert(list_.end(), key); // Create the key-value entry, linked to the usage record. map_.insert(std::make_pair(key, std::make_pair(val, it))); }
/// Inserts the given query, result pair into the cache. void CachingSolver::cacheInsert(const Query& query, IncompleteSolver::PartialValidity result) { bool negationUsed; ref<Expr> canonicalQuery = canonicalizeQuery(query.expr, negationUsed); CacheEntry ce(query.constraints, canonicalQuery); IncompleteSolver::PartialValidity cachedResult = (negationUsed ? IncompleteSolver::negatePartialValidity(result) : result); cache.insert(std::make_pair(ce, cachedResult)); }
// returns the program cache for the context inline boost::shared_ptr<program_cache> get_program_cache(const context &context) { typedef lru_cache<cl_context, boost::shared_ptr<program_cache> > cache_map; static cache_map caches(8); boost::shared_ptr<program_cache> cache = caches.get(context.get()); if(!cache){ cache = boost::make_shared<program_cache>(64); caches.insert(context.get(), cache); } return cache; }
Result Cache<Result(Args...)>::operator()(Args... args) { argument_tuple tup{args...}; auto map_iter = map.find(tup); bool insert = map_iter == map.end(); log.push_back(nullptr); ScopeFailure guard([&] { log.pop_back(); }); if (insert) map_iter = map.insert({tup, {tuple_invoke(fun, tup), {}}}).first; log.back() = &map_iter->first; if (! insert) log.erase(map_iter->second.log_iter); map_iter->second.log_iter = std::prev(log.end()); if (insert && map.size() > cap) { map.erase(*log.front()); log.pop_front(); } return map_iter->second.result; }