get number of lines in a file

helper func ************************/

load access pattern plot data from C++ computation Args: datapath: the path to the access pattern data file n_obj: the number of o

load future_reuse distribution plot data from C++ computation

load request rate plot data from C++ computation Args: datapath: path to the reqRate data file Return: req_rate_list: list of

load reuse distribution plot data from C++ computation Args: datapath (str): the path of reuse data file Returns: Tuple[dict

load scan size plot data from C++ computation

load size distribution plot data from C++ computation Args: datapath (str): the path of size data file Returns: Tuple[dict,

load write_reuse distribution plot data from C++ computation Args: datapath: path to the write_reuse data file Return: read_

read decompressed data file */

read zstd compressed data */

* begin substring search functions * *********************************************************************

Build KMP table from right to left. */

Search data from left to right. ( Multiple search mode. ) */

Search data from right to left. ( Multiple search mode. ) */

wyhash function

* @brief add a cache server to the cluster, return the index of the server * * @param cache_server * @return uint64_t */

* @brief This function get called before admitting object. Using modified size * probability with C param * @param req * @return true / false */

Arithmetic: we just do arithmetic on pos. We don't even need to do bounds checking, since STL doesn't consider that its job. :-) NOTE: this is not a

allocates, but does NOT initialize. Use in-place new constructor, e.g. T* obj = pool.allocate(); ::new (static_cast<void*>(obj)) T();

@brief Get the last element. @return The last element.

Return true if malloced space is not necessarily cleared

the user needs to make sure the added object is not in the hash table */

support for mallopt

Update weight and history, only called in cache miss.

* @brief check whether the trace uses the given delimiter by making sure * the delimiter is in each line * * @param reader * @param delimit

@brief Check if the given hexadecimals are safely converted into 1 byte integer. @param octs The pointer to hexadecimal characters @param len The leng

@brief Check if the given octals are safely converted into 1 byte integer. @param octs The pointer to octal characters @param len The length of octal

currently we snapshot segments after each training, then we collect segment * utility for the snapshotted segments over time, when it is time to retr

* @brief create a new cache with the same size as the old cache * * @param old_cache * @param new_size * @return cache_t* */

@brief convert the cache size string to byte, * example input1: 1024,2048,4096,8192 * example input2: 1GB,2GB,4GB,8GB * example input3: 1024 * exa

@brief convert the cache size string to byte, * example input1: 1024,2048,4096,8192 * example input2: 1GB,2GB,4GB,8GB * example input3: 1024 * exa

* * @brief convert cache size string to byte, e.g., 100MB -> 100 * 1024 * 1024 * the cache size can be an integer or a string with suffix KB/MB/GB

convert the size string to int in bytes (or number of objects) Args: size_str: the size string, e.g., 1.5GiB, 1024KiB, 1024, 1.5, etc.

* @brief Convert a trace to oracleGeneral format, which is a binary format * that has time, obj_id, obj_size, next_access_vtime, where *

@brief Update the target YAML version with an input string. @param version_str A YAML version string.

@brief copy a segment to training data matrix * * @param cache * @param seg */

* @brief count the number of times char c appears in string str * * @param str * @param c * @return int */

Helper function to get cache constructor by algorithm name

* @brief this function is called by all eviction algorithms to clone old cache * with new size * * @param old_cache * @param new_size * @return c

hashtable func ************************/

* @brief detect delimiter in the csv trace * it uses a simple algorithm: count the occurrence of each possible delimiter * in the first line, the de

* @brief detect whether the csv trace has header, * it uses a simple algorithm: compare the number of digits and letters in the * first line, if the

* @brief read one request from a csv file * * @param reader * @param req * @return int */

* @brief setup a csv reader * * @param reader */

@brief Get the pointer to the raw data of referenced character sequence. @return The pointer to the raw data of referenced character sequence.

does not actually deallocate but puts it in store. make sure you have already called the destructor! e.g. with obj->~T(); pool.deallocate(obj);