// 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;
}
/** @returns true on a cache hit, false of a cache miss. Reference
value result only valid on a cache hit. */
bool CachingSolver::cacheLookup(const Query& query,
IncompleteSolver::PartialValidity &result) {
bool negationUsed;
ref<Expr> canonicalQuery = canonicalizeQuery(query.expr, negationUsed);
CacheEntry ce(query.constraints, canonicalQuery);
cache_map::iterator it = cache.find(ce);
if (it != cache.end()) {
result = (negationUsed ?
IncompleteSolver::negatePartialValidity(it->second) :
it->second);
return true;
}
return false;
}
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)));
}
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;
}
/// 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));
}
// Purge the least-recently-used element in the cache
void evict()
{
// Assert method is never called when cache is empty
assert(!list_.empty());
if( list_.empty() )
return;
// Identify least recently used key
map_const_iterator it = map_.find(list_.front());
assert(it != map_.end());
if( it == map_.end() )
return;
if( it->second.first.second != 0 )
it->second.first.second(list_.front(), it->second.first.first);
// Erase both elements to completely purge record
map_.erase(it);
list_.pop_front();
}
~CachingSolver() { cache.clear(); delete solver; }
~CachingSolver() { cache.clear(); unsat_core_store.clear(); delete solver; }
// 清空所有数据
void clear()
{
list_.clear();
map_.clear();
}
std::pair<bool, map_iterator> exsit(const cache_key_type& k)
{
// Attempt to find existing record
map_iterator iter = map_.find(k);
return std::make_pair(iter != map_.end(), iter);
}
map_const_iterator end() const
{
return map_.end();
}
map_iterator end()
{
return map_.end();
}
map_const_iterator begin() const
{
return map_.begin();
}
map_iterator begin()
{
return map_.begin();
}
/** Swap the content of two cache_map instances.
*
* @param m1 a cache_map
* @param m2 another cache_map
*/
friend inline void swap(
cache_map<Key,T,HashFunction,KeyEqual,DiscardFunction,Allocator>& m1,
cache_map<Key,T,HashFunction,KeyEqual,DiscardFunction,Allocator>& m2 )
{
m1.swap( m2 );
}
