DataBufferCache Class Reference

#include <TableFunctionsCommon.hpp>

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_

Detailed Description

Definition at line 96 of file TableFunctionsCommon.hpp.

Member Function Documentation

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

private

Definition at line 507 of file TableFunctionsCommon.cpp.

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

Definition at line 452 of file TableFunctionsCommon.cpp.

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

Definition at line 477 of file TableFunctionsCommon.cpp.

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

Definition at line 466 of file TableFunctionsCommon.cpp.

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

Definition at line 436 of file TableFunctionsCommon.cpp.

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

Definition at line 441 of file TableFunctionsCommon.cpp.

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
	)

Definition at line 487 of file TableFunctionsCommon.cpp.

References cache_mutex_, copyData(), data_cache_, 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()) {
    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 123 of file TableFunctionsCommon.hpp.

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 122 of file TableFunctionsCommon.hpp.

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

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

private

Definition at line 118 of file TableFunctionsCommon.hpp.

Referenced by copyData().

---

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

• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/TableFunctions/SystemFunctions/os/Shared/TableFunctionsCommon.hpp
• /home/jenkins-slave/workspace/core-os-doxygen/QueryEngine/TableFunctions/SystemFunctions/os/Shared/TableFunctionsCommon.cpp