DataBufferCache Class Reference

#include <TableFunctionsDataCache.h>

Public Member Functions
bool	isKeyCached (const std::string &key) const
bool	isKeyCachedAndSameLength (const std::string &key, const size_t num_bytes) const
template<typename T >
void	getDataForKey (const std::string &key, T *dest_buffer) const
template<typename T >
const T &	getDataRefForKey (const std::string &key) const
template<typename T >
const T *	getDataPtrForKey (const std::string &key) const
template<typename T >
void	putDataForKey (const std::string &key, T *const data_buffer, const size_t num_elements)

Private Member Functions
void	copyData (int8_t *dest, const int8_t *source, const size_t num_bytes) const

Private Attributes
const size_t	parallel_copy_min_bytes {1 << 20}
std::unordered_map < std::string, std::shared_ptr < CacheDataTf > >	data_cache_
std::shared_mutex	cache_mutex_

Static Private Attributes
static constexpr bool	debug_print_ {false}

Detailed Description

Definition at line 41 of file TableFunctionsDataCache.h.

Member Function Documentation

void DataBufferCache::copyData ( int8_t *  dest, const int8_t *  source, const size_t  num_bytes  ) const

inlineprivate

Definition at line 118 of file TableFunctionsDataCache.h.

References parallel_copy_min_bytes, and threading_serial::parallel_for().

Referenced by getDataForKey(), and putDataForKey().

                                                                                  {
    if (num_bytes < parallel_copy_min_bytes) {
      std::memcpy(dest, source, num_bytes);
      return;
    }
    const size_t max_bytes_per_thread = parallel_copy_min_bytes;
    const size_t num_threads =
        (num_bytes + max_bytes_per_thread - 1) / max_bytes_per_thread;
    tbb::parallel_for(
        tbb::blocked_range<size_t>(0, num_threads, 1),
        [&](const tbb::blocked_range<size_t>& r) {
          const size_t end_chunk_idx = r.end();
          for (size_t chunk_idx = r.begin(); chunk_idx != end_chunk_idx; ++chunk_idx) {
            const size_t start_byte = chunk_idx * max_bytes_per_thread;
            const size_t length =
                std::min(start_byte + max_bytes_per_thread, num_bytes) - start_byte;
            std::memcpy(dest + start_byte, source + start_byte, length);
          }
        });
  }

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >

void DataBufferCache::getDataForKey ( const std::string &  key, T *  dest_buffer  ) const

inline

Definition at line 58 of file TableFunctionsDataCache.h.

References cache_mutex_, copyData(), data_cache_, and DEBUG_TIMER.

                                                                 {
    auto timer = DEBUG_TIMER(__func__);
    std::shared_lock<std::shared_mutex> read_lock(cache_mutex_);
    const auto& cached_data_itr = data_cache_.find(key);
    if (cached_data_itr == data_cache_.end()) {
      const std::string error_msg = "Data for key " + key + " not found in cache.";
      throw std::runtime_error(error_msg);
    }
    copyData(reinterpret_cast<int8_t*>(dest_buffer),
             cached_data_itr->second->data_buffer,
             cached_data_itr->second->num_bytes);
  }

Here is the call graph for this function:

template<typename T >

const T* DataBufferCache::getDataPtrForKey ( const std::string &  key ) const

inline

Definition at line 83 of file TableFunctionsDataCache.h.

References cache_mutex_, data_cache_, and heavydb.dtypes::T.

                                                        {
    std::shared_lock<std::shared_mutex> read_lock(cache_mutex_);
    const auto& cached_data_itr = data_cache_.find(key);
    if (cached_data_itr == data_cache_.end()) {
      return nullptr;
    }
    return reinterpret_cast<const T* const>(cached_data_itr->second->data_buffer);
  }

template<typename T >

const T& DataBufferCache::getDataRefForKey ( const std::string &  key ) const

inline

Definition at line 72 of file TableFunctionsDataCache.h.

References cache_mutex_, data_cache_, and heavydb.dtypes::T.

                                                        {
    std::shared_lock<std::shared_mutex> read_lock(cache_mutex_);
    const auto& cached_data_itr = data_cache_.find(key);
    if (cached_data_itr == data_cache_.end()) {
      const std::string error_msg{"Data for key " + key + " not found in cache."};
      throw std::runtime_error(error_msg);
    }
    return *reinterpret_cast<const T*>(cached_data_itr->second->data_buffer);
  }

bool DataBufferCache::isKeyCached ( const std::string &  key ) const

inline

Definition at line 43 of file TableFunctionsDataCache.h.

References cache_mutex_, and data_cache_.

                                               {
    std::shared_lock<std::shared_mutex> read_lock(cache_mutex_);
    return data_cache_.count(key) > 0;
  }

bool DataBufferCache::isKeyCachedAndSameLength ( const std::string &  key, const size_t  num_bytes  ) const

inline

Definition at line 48 of file TableFunctionsDataCache.h.

References cache_mutex_, and data_cache_.

                                                                                    {
    std::shared_lock<std::shared_mutex> read_lock(cache_mutex_);
    const auto& cached_data_itr = data_cache_.find(key);
    if (cached_data_itr == data_cache_.end()) {
      return false;
    }
    return num_bytes == cached_data_itr->second->num_bytes;
  }

template<typename T >

void DataBufferCache::putDataForKey ( const std::string &  key, T *const  data_buffer, const size_t  num_elements  )

inline

Definition at line 93 of file TableFunctionsDataCache.h.

References cache_mutex_, copyData(), data_cache_, debug_print_, DEBUG_TIMER, and heavydb.dtypes::T.

                                                {
    auto timer = DEBUG_TIMER(__func__);
    const size_t num_bytes(num_elements * sizeof(T));
    auto cache_data = std::make_shared<CacheDataTf>(num_bytes);
    copyData(cache_data->data_buffer, reinterpret_cast<int8_t*>(data_buffer), num_bytes);
    std::unique_lock<std::shared_mutex> write_lock(cache_mutex_);
    const auto& cached_data_itr = data_cache_.find(key);
    if (data_cache_.find(key) != data_cache_.end()) {
      if constexpr (debug_print_) {
        const std::string warning_msg =
            "Data for key " + key + " already exists in cache. Replacing.";
        std::cout << warning_msg << std::endl;
      }
      cached_data_itr->second.reset();
      cached_data_itr->second = cache_data;
      return;
    }
    data_cache_.insert(std::make_pair(key, cache_data));
  }

Here is the call graph for this function:

Member Data Documentation

std::shared_mutex DataBufferCache::cache_mutex_

mutableprivate

Definition at line 140 of file TableFunctionsDataCache.h.

Referenced by getDataForKey(), getDataPtrForKey(), getDataRefForKey(), isKeyCached(), isKeyCachedAndSameLength(), and putDataForKey().

std::unordered_map<std::string, std::shared_ptr<CacheDataTf> > DataBufferCache::data_cache_

private

Definition at line 139 of file TableFunctionsDataCache.h.

Referenced by getDataForKey(), getDataPtrForKey(), getDataRefForKey(), isKeyCached(), isKeyCachedAndSameLength(), and putDataForKey().

constexpr bool DataBufferCache::debug_print_ {false}

staticprivate

Definition at line 141 of file TableFunctionsDataCache.h.

Referenced by putDataForKey().

const size_t DataBufferCache::parallel_copy_min_bytes {1 << 20}

private

Definition at line 116 of file TableFunctionsDataCache.h.

Referenced by copyData().

---

The documentation for this class was generated from the following file:

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/TableFunctions/SystemFunctions/os/Shared/TableFunctionsDataCache.h