#include <CodeCacheAccessor.h>

Collaboration diagram for CodeCacheAccessor< CompilationContext >:

Public Member Functions
	CodeCacheAccessor (EvictionMetricType eviction_metric_type, size_t max_cache_size, std::string name)

CodeCacheVal< CompilationContext >	get_value (const CodeCacheKey &key)

bool	put (const CodeCacheKey &key, CodeCacheVal< CompilationContext > &value)

CodeCacheVal < CompilationContext > *	get_or_wait (const CodeCacheKey &key)

void	reset (const CodeCacheKey &key, CodeCacheVal< CompilationContext > value)

void	erase (const CodeCacheKey &key)

void	clear ()

size_t	computeNumEntriesToEvict (const float fraction)

void	evictEntries (const size_t n)

size_t	getCacheSize ()

void	resetCache (size_t new_max_size)

CodeCacheMetric	getCodeCacheMetric ()

Private Attributes
CodeCache< CompilationContext >	code_cache_

EvictionMetricType const	eviction_metric_type_

int64_t	get_count_

int64_t	found_count_

int64_t	put_count_

int64_t	ignore_count_

int64_t	overwrite_count_

int64_t	evict_count_

const std::string	name_

std::mutex	code_cache_mutex_

std::condition_variable	compilation_cv_

Friends
std::ostream &	operator<< (std::ostream &os, CodeCacheAccessor &c)

Detailed Description

template<typename CompilationContext>
class CodeCacheAccessor< CompilationContext >

Definition at line 38 of file CodeCacheAccessor.h.

Constructor & Destructor Documentation

template<typename CompilationContext >

CodeCacheAccessor< CompilationContext >::CodeCacheAccessor	(	EvictionMetricType	eviction_metric_type,
		size_t	max_cache_size,
		std::string	name
	)

inline

Definition at line 40 of file CodeCacheAccessor.h.

References EntryCount, CodeCacheAccessor< CompilationContext >::eviction_metric_type_, logger::INFO, LOG, and CodeCacheAccessor< CompilationContext >::name_.

       : code_cache_(eviction_metric_type, max_cache_size)
       , eviction_metric_type_(eviction_metric_type)
       , get_count_(0)
       , found_count_(0)
       , put_count_(0)
       , ignore_count_(0)
       , overwrite_count_(0)
       , evict_count_(0)
       , name_(std::move(name)) {
     std::ostringstream oss;
     std::string eviction_type = eviction_metric_type_ == EvictionMetricType::EntryCount
                                     ? "EntryCount"
                                     : "ByteSize";
     oss << "Initialize a code cache (name: " << name_
         << ", eviction_metric_type: " << eviction_type
         << ", max_cache_size: " << max_cache_size << ")";
     LOG(INFO) << oss.str();
   }

Member Function Documentation

template<typename CompilationContext >

void CodeCacheAccessor< CompilationContext >::clear ( )

Definition at line 113 of file CodeCacheAccessor.cpp.

                                                   {
   std::lock_guard<std::mutex> lock(code_cache_mutex_);
   code_cache_.clear();
 }

template<typename CompilationContext >

size_t CodeCacheAccessor< CompilationContext >::computeNumEntriesToEvict ( const float fraction )

inline

Definition at line 73 of file CodeCacheAccessor.h.

References CodeCacheAccessor< CompilationContext >::code_cache_, and CodeCacheAccessor< CompilationContext >::code_cache_mutex_.

                                                         {
     std::lock_guard<std::mutex> lock(code_cache_mutex_);
     return code_cache_.computeNumEntriesToEvict(fraction);
   }

template<typename CompilationContext >

void CodeCacheAccessor< CompilationContext >::erase ( const CodeCacheKey & key )

Definition at line 106 of file CodeCacheAccessor.cpp.

                                                                          {
   std::lock_guard<std::mutex> lock(code_cache_mutex_);
   code_cache_.erase(key);
   compilation_cv_.notify_all();  // notify waiting get_or_wait(..) calls
 }

template<typename CompilationContext >

void CodeCacheAccessor< CompilationContext >::evictEntries ( const size_t n )

inline

Definition at line 78 of file CodeCacheAccessor.h.

References CodeCacheAccessor< CompilationContext >::code_cache_, CodeCacheAccessor< CompilationContext >::code_cache_mutex_, and CodeCacheAccessor< CompilationContext >::evict_count_.

                                     {
     std::lock_guard<std::mutex> lock(code_cache_mutex_);
     evict_count_++;
     code_cache_.evictNEntries(n);
   }

template<typename CompilationContext >

CodeCacheVal< CompilationContext > * CodeCacheAccessor< CompilationContext >::get_or_wait ( const CodeCacheKey & key )

Definition at line 59 of file CodeCacheAccessor.cpp.

References CHECK, and VLOG.

                              {
   std::unique_lock<std::mutex> lk(code_cache_mutex_);
   get_count_++;
   if (auto* cached_code = code_cache_.get(key)) {
     if (!cached_code->get()) {
       // Wait until the compiling thread puts code to cache. TODO:
       // this wait also locks other unrelated get_or_wait calls on
       // different keys. This is suboptimal as it will block also
       // independent get_or_wait(other_key) calls. To fix this (it
       // likely also requires using ORCJIT to enable concurrent
       // compilations), we'll need a key specific mutex or use some
       // other approach that would allow threads with other keys to
       // proceed.
       compilation_cv_.wait(lk, [=] { return cached_code->get(); });
       // Don't ignore spurious awakenings as the support for such
       // events has not been implemented:
       CHECK(cached_code->get());
     }
     found_count_++;
     VLOG(1) << name_ << ": Reuse a cached compiled code";
     return cached_code;
   }
   // This is the first time the key is used to acquire code from
   // cache. Put null value to cache so that other threads acquiring
   // the same key will wait (see above) until the code is put to the
   // cache:
   CodeCacheVal<CompilationContext> not_a_code(nullptr);
   evict_count_ += code_cache_.put(key, std::move(not_a_code));
   // returning nullptr will notify caller to trigger code compilation
   // for the given key:
   return nullptr;
 }

template<typename CompilationContext >

CodeCacheVal< CompilationContext > CodeCacheAccessor< CompilationContext >::get_value ( const CodeCacheKey & key )

Definition at line 21 of file CodeCacheAccessor.cpp.

References VLOG.

                              {
   std::lock_guard<std::mutex> lock(code_cache_mutex_);
   get_count_++;
   auto it = code_cache_.find(key);
   if (it != code_cache_.cend()) {
     found_count_++;
     VLOG(1) << name_ << ": Reuse cached compiled kernel";
     return it->second;
   }
   return {};
 }

template<typename CompilationContext >

size_t CodeCacheAccessor< CompilationContext >::getCacheSize ( )

inline

Definition at line 93 of file CodeCacheAccessor.h.

References CodeCacheAccessor< CompilationContext >::code_cache_, and CodeCacheAccessor< CompilationContext >::code_cache_mutex_.

                         {
     std::lock_guard<std::mutex> lock(code_cache_mutex_);
     return code_cache_.size();
   }

template<typename CompilationContext >

CodeCacheMetric CodeCacheAccessor< CompilationContext >::getCodeCacheMetric ( )

inline

Definition at line 104 of file CodeCacheAccessor.h.

References CodeCacheAccessor< CompilationContext >::code_cache_mutex_, CodeCacheAccessor< CompilationContext >::evict_count_, CodeCacheAccessor< CompilationContext >::found_count_, CodeCacheAccessor< CompilationContext >::get_count_, CodeCacheAccessor< CompilationContext >::ignore_count_, CodeCacheAccessor< CompilationContext >::overwrite_count_, and CodeCacheAccessor< CompilationContext >::put_count_.

                                        {
     std::lock_guard<std::mutex> lock(code_cache_mutex_);
     return {get_count_,
             found_count_,
             put_count_,
             ignore_count_,
             overwrite_count_,
             evict_count_};
   }

template<typename CompilationContext >

bool CodeCacheAccessor< CompilationContext >::put	(	const CodeCacheKey &	key,
		CodeCacheVal< CompilationContext > &	value
	)

Definition at line 35 of file CodeCacheAccessor.cpp.

References LOG, VLOG, and logger::WARNING.

                                                                                          {
   bool warn = false;
   {
     std::lock_guard<std::mutex> lock(code_cache_mutex_);
     // if key is in cache, put is no-op
     auto it = code_cache_.find(key);
     put_count_++;
     if (it == code_cache_.cend()) {
       VLOG(1) << name_ << ": Add compiled kernel to code cache";
       evict_count_ += code_cache_.put(key, value);
     } else {
       ignore_count_++;
       warn = true;
     }
   }
   if (warn) {
     LOG(WARNING) << *this << ": code already in cache, ignoring.\n";
     return false;
   }
   return true;
 }

template<typename CompilationContext >

void CodeCacheAccessor< CompilationContext >::reset	(	const CodeCacheKey &	key,
		CodeCacheVal< CompilationContext >	value
	)

Definition at line 94 of file CodeCacheAccessor.cpp.

References CHECK, and run_benchmark_import::result.

                                             {
   std::lock_guard<std::mutex> lock(code_cache_mutex_);
   auto result = code_cache_.get(key);
   CHECK(result);          // get_or_wait has put not_a_code to code cache
   CHECK(!result->get());  // ensure that result really contains not_a_code per get_or_wait
   *result = std::move(value);    // set actual code
   compilation_cv_.notify_all();  // notify waiting get_or_wait(..) calls
 }

template<typename CompilationContext >

void CodeCacheAccessor< CompilationContext >::resetCache ( size_t new_max_size )

inline

Definition at line 98 of file CodeCacheAccessor.h.

References CHECK, CodeCacheAccessor< CompilationContext >::code_cache_, CodeCacheAccessor< CompilationContext >::code_cache_mutex_, CodeCacheAccessor< CompilationContext >::eviction_metric_type_, and g_is_test_env.

                                        {
     CHECK(g_is_test_env) << "Call the resetCache function from non-test env.";
     std::lock_guard<std::mutex> lock(code_cache_mutex_);
     code_cache_ = CodeCache<CompilationContext>(eviction_metric_type_, new_max_size);
   }

Friends And Related Function Documentation

template<typename CompilationContext >

std::ostream& operator<<	(	std::ostream &	os,
		CodeCacheAccessor< CompilationContext > &	c
	)

friend

Definition at line 84 of file CodeCacheAccessor.h.

                                                                       {
     std::lock_guard<std::mutex> lock(c.code_cache_mutex_);
     os << "CodeCacheAccessor<" << c.name_ << ">[current size=" << c.code_cache_.size()
        << ", total get/found count=" << c.get_count_ << "/" << c.found_count_
        << ", total put/ignore/overwrite count=" << c.put_count_ << "/" << c.ignore_count_
        << "/" << c.overwrite_count_ << ", total evict count=" << c.evict_count_ << "]";
     return os;
   }