fbba23e66d
copy dummy cache over implement retrievePackedPathFromSearchSpace calculate packed_path_from_source_to_middle debugging the retrievePackedPathFromSearchSpace function implementation adding in packed_path_from_source_to_middle cache is partway working unpack path and get duration that way the computeDurationForEdge method comment out cache clean up the code move vector creation and allocation to outside of loop hack to not return vectors on facade.GetUncompressedForwardDurations and facade.GetUncompressedReverseDurations clean up hack add exclude_index to cache key clearing cache with timestamp rebase against vectors->range pr swapped out unordered_map cache with a boost_lru implementation calculation for cache size cleaned up comment about cache size calculations unit tests cache uses unsigned char for exclude index clean up cache and unit tests pass in a hashed key to the threadlocal cache 500 mb threadlocal 2 t fixes and a rebase correct calculation
139 lines
3.4 KiB
C++
139 lines
3.4 KiB
C++
//---------------------------------------------------------------------------//
|
|
// Copyright (c) 2013 Kyle Lutz <kyle.r.lutz@gmail.com>
|
|
//
|
|
// Distributed under the Boost Software License, Version 1.0
|
|
// See accompanying file LICENSE_1_0.txt or copy at
|
|
// http://www.boost.org/LICENSE_1_0.txt
|
|
//
|
|
// See http://boostorg.github.com/compute for more information.
|
|
//---------------------------------------------------------------------------//
|
|
|
|
#ifndef BOOST_COMPUTE_DETAIL_LRU_CACHE_HPP
|
|
#define BOOST_COMPUTE_DETAIL_LRU_CACHE_HPP
|
|
|
|
#include <map>
|
|
#include <list>
|
|
#include <utility>
|
|
|
|
#include <boost/optional.hpp>
|
|
|
|
namespace boost {
|
|
namespace compute {
|
|
namespace detail {
|
|
|
|
// a cache which evicts the least recently used item when it is full
|
|
template<class Key, class Value>
|
|
class lru_cache
|
|
{
|
|
public:
|
|
typedef Key key_type;
|
|
typedef Value value_type;
|
|
typedef std::list<key_type> list_type;
|
|
typedef std::map<
|
|
key_type,
|
|
std::pair<value_type, typename list_type::iterator>
|
|
> map_type;
|
|
|
|
lru_cache(size_t capacity)
|
|
: m_capacity(capacity)
|
|
{
|
|
}
|
|
|
|
~lru_cache()
|
|
{
|
|
}
|
|
|
|
size_t size() const
|
|
{
|
|
return m_map.size();
|
|
}
|
|
|
|
size_t capacity() const
|
|
{
|
|
return m_capacity;
|
|
}
|
|
|
|
bool empty() const
|
|
{
|
|
return m_map.empty();
|
|
}
|
|
|
|
bool contains(const key_type &key)
|
|
{
|
|
return m_map.find(key) != m_map.end();
|
|
}
|
|
|
|
void insert(const key_type &key, const value_type &value)
|
|
{
|
|
typename map_type::iterator i = m_map.find(key);
|
|
if(i == m_map.end()){
|
|
// insert item into the cache, but first check if it is full
|
|
if(size() >= m_capacity){
|
|
// cache is full, evict the least recently used item
|
|
evict();
|
|
}
|
|
|
|
// insert the new item
|
|
m_list.push_front(key);
|
|
m_map[key] = std::make_pair(value, m_list.begin());
|
|
}
|
|
}
|
|
|
|
boost::optional<value_type> get(const key_type &key)
|
|
{
|
|
// lookup value in the cache
|
|
typename map_type::iterator i = m_map.find(key);
|
|
if(i == m_map.end()){
|
|
// value not in cache
|
|
return boost::none;
|
|
}
|
|
|
|
// return the value, but first update its place in the most
|
|
// recently used list
|
|
typename list_type::iterator j = i->second.second;
|
|
if(j != m_list.begin()){
|
|
// move item to the front of the most recently used list
|
|
m_list.erase(j);
|
|
m_list.push_front(key);
|
|
|
|
// update iterator in map
|
|
j = m_list.begin();
|
|
const value_type &value = i->second.first;
|
|
m_map[key] = std::make_pair(value, j);
|
|
|
|
// return the value
|
|
return value;
|
|
}
|
|
else {
|
|
// the item is already at the front of the most recently
|
|
// used list so just return it
|
|
return i->second.first;
|
|
}
|
|
}
|
|
|
|
void clear()
|
|
{
|
|
m_map.clear();
|
|
m_list.clear();
|
|
}
|
|
|
|
private:
|
|
void evict()
|
|
{
|
|
// evict item from the end of most recently used list
|
|
typename list_type::iterator i = --m_list.end();
|
|
m_map.erase(*i);
|
|
m_list.erase(i);
|
|
}
|
|
|
|
private:
|
|
map_type m_map;
|
|
list_type m_list;
|
|
size_t m_capacity;
|
|
};
|
|
|
|
} // end detail namespace
|
|
} // end compute namespace
|
|
} // end boost namespace
|
|
|
|
#endif // BOOST_COMPUTE_DETAIL_LRU_CACHE_HPP
|