A device detection library that is used natively or by 51Degrees products

cache.h

1/* *********************************************************************
2 * This Original Work is copyright of 51 Degrees Mobile Experts Limited.
3 * Copyright 2026 51 Degrees Mobile Experts Limited, Davidson House,
4 * Forbury Square, Reading, Berkshire, United Kingdom RG1 3EU.
5 *
6 * This Original Work is licensed under the European Union Public Licence
7 * (EUPL) v.1.2 and is subject to its terms as set out below.
8 *
9 * If a copy of the EUPL was not distributed with this file, You can obtain
10 * one at https://opensource.org/licenses/EUPL-1.2.
11 *
12 * The 'Compatible Licences' set out in the Appendix to the EUPL (as may be
13 * amended by the European Commission) shall be deemed incompatible for
14 * the purposes of the Work and the provisions of the compatibility
15 * clause in Article 5 of the EUPL shall not apply.
16 *
17 * If using the Work as, or as part of, a network application, by
18 * including the attribution notice(s) required under Article 5 of the EUPL
19 * in the end user terms of the application under an appropriate heading,
20 * such notice(s) shall fulfill the requirements of that article.
21 * ********************************************************************* */
22
91
92#ifndef FIFTYONE_DEGREES_CACHE_H_INCLUDED
93#define FIFTYONE_DEGREES_CACHE_H_INCLUDED
94
95#ifdef FIFTYONE_DEGREES_IPI_SYMBOLS
96#include "ipiSymbols.h"
97#endif
98
99/* Define NDEBUG if needed, to ensure asserts are disabled in release builds */
100#if !defined(DEBUG) && !defined(_DEBUG) && !defined(NDEBUG)
101#define NDEBUG
102#endif
103
104#include <stdint.h>
105#include <stdbool.h>
106
107#ifdef _MSC_VER
108#endif
109#ifdef _MSC_VER
110#pragma warning (push)
111#pragma warning (disable: 5105)
112#include <windows.h>
113#pragma warning (default: 5105)
114#pragma warning (pop)
115#endif
116#include <assert.h>
117#include "data.h"
118#include "exceptions.h"
119#include "tree.h"
120#include "common.h"
121
122#ifndef FIFTYONE_DEGREES_NO_THREADING
123#include "threading.h"
124#endif
125
127typedef struct fiftyone_degrees_cache_node_t fiftyoneDegreesCacheNode;
128typedef struct fiftyone_degrees_cache_shard_t fiftyoneDegreesCacheShard;
129typedef struct fiftyone_degrees_cache_t fiftyoneDegreesCache;
131
136typedef struct fiftyone_degrees_cache_node_t {
137 fiftyoneDegreesTreeNode tree;
138 fiftyoneDegreesData data;
139 fiftyoneDegreesCacheShard *shard;
140 fiftyoneDegreesCacheNode *listPrevious;
141 fiftyoneDegreesCacheNode *listNext;
142 int activeCount;
143} fiftyoneDegreesCacheNode;
144
148typedef struct fiftyone_degrees_cache_shard_t {
149 fiftyoneDegreesCache *cache;
151 fiftyoneDegreesTreeRoot root;
152 uint32_t capacity;
153 uint32_t allocated;
154 fiftyoneDegreesCacheNode *nodes;
155 fiftyoneDegreesCacheNode *first;
157 fiftyoneDegreesCacheNode *last;
159#ifndef FIFTYONE_DEGREES_NO_THREADING
160 fiftyoneDegreesMutex lock;
162#endif
163} fiftyoneDegreesCacheShard;
164
173typedef void(*fiftyoneDegreesCacheLoadMethod)(
174 const void *state,
175 fiftyoneDegreesData *data,
176 const void *key,
177 fiftyoneDegreesException *exception);
178
184typedef int64_t(*fiftyoneDegreesCacheHashCodeMethod)(const void* key);
185
191typedef struct fiftyone_degrees_cache_t {
192 fiftyoneDegreesCacheShard *shards;
193 fiftyoneDegreesCacheNode *nodes;
194 uint16_t concurrency;
195 int32_t capacity;
196 unsigned long hits;
197 unsigned long misses;
198 fiftyoneDegreesCacheLoadMethod load;
200 fiftyoneDegreesCacheHashCodeMethod hash;
201 const void* loaderState;
202} fiftyoneDegreesCache;
203
214EXTERNAL fiftyoneDegreesCache *fiftyoneDegreesCacheCreate(
215 uint32_t capacity,
216 uint16_t concurrency,
217 fiftyoneDegreesCacheLoadMethod load,
218 fiftyoneDegreesCacheHashCodeMethod hash,
219 const void *state);
220
225EXTERNAL void fiftyoneDegreesCacheFree(fiftyoneDegreesCache *cache);
226
249EXTERNAL fiftyoneDegreesCacheNode* fiftyoneDegreesCacheGet(
250 fiftyoneDegreesCache *cache,
251 const void *key,
252 fiftyoneDegreesException *exception);
253
259EXTERNAL void fiftyoneDegreesCacheRelease(fiftyoneDegreesCacheNode *node);
260
268EXTERNAL int64_t fiftyoneDegreesCacheHash32(const void *key);
269
277EXTERNAL int64_t fiftyoneDegreesCacheHash64(const void *key);
278
282#endif
fiftyoneDegreesCacheCreate
fiftyoneDegreesCache * fiftyoneDegreesCacheCreate(uint32_t capacity, uint16_t concurrency, fiftyoneDegreesCacheLoadMethod load, fiftyoneDegreesCacheHashCodeMethod hash, const void *state)
Creates a new cache.The cache must be destroyed with the fiftyoneDegreesCacheFree method.
fiftyoneDegreesCacheGet
fiftyoneDegreesCacheNode * fiftyoneDegreesCacheGet(fiftyoneDegreesCache *cache, const void *key, fiftyoneDegreesException *exception)
Gets an item from the cache.
fiftyoneDegreesCacheRelease
void fiftyoneDegreesCacheRelease(fiftyoneDegreesCacheNode *node)
Releases the cache node previous obtained via fiftyoneDegreesCacheGet so that it can be evicted from ...
fiftyoneDegreesCacheHash32
int64_t fiftyoneDegreesCacheHash32(const void *key)
Passed a pointer to a 32 bit / 4 byte data structure and returns the data as a 64 bit / 8 byte value ...
fiftyoneDegreesCacheLoadMethod
void(* fiftyoneDegreesCacheLoadMethod)(const void *state, fiftyoneDegreesData *data, const void *key, fiftyoneDegreesException *exception)
Method used to load data into the cache.
Definition cache.h:173
fiftyoneDegreesCacheHash64
int64_t fiftyoneDegreesCacheHash64(const void *key)
Passed a pointer to a 64 bit / 8 byte data structure and returns the data as a 64 bit / 8 byte value ...
fiftyoneDegreesCacheHashCodeMethod
int64_t(* fiftyoneDegreesCacheHashCodeMethod)(const void *key)
Method used to calculate a hash code from the key.
Definition cache.h:184
fiftyoneDegreesCacheFree
void fiftyoneDegreesCacheFree(fiftyoneDegreesCache *cache)
Frees the cache structure, all allocated nodes and their data.
fiftyoneDegreesMutex
pthread_mutex_t fiftyoneDegreesMutex
MUTEX AND THREADING MACROS.
Definition threading.h:98
fiftyoneDegreesCache
Cache structure to store the root of the red black tree and a list of allocated cache nodes.
Definition cache.h:191
fiftyoneDegreesCache::shards
fiftyoneDegreesCacheShard * shards
Array of shards / concurrency.
Definition cache.h:192
fiftyoneDegreesCache::hash
fiftyoneDegreesCacheHashCodeMethod hash
Used to hash a key pointer.
Definition cache.h:200
fiftyoneDegreesCache::hits
unsigned long hits
The requests served from the cache.
Definition cache.h:196
fiftyoneDegreesCache::loaderState
const void * loaderState
Cache loader specific state.
Definition cache.h:201
fiftyoneDegreesCache::capacity
int32_t capacity
Capacity of the cache.
Definition cache.h:195
fiftyoneDegreesCache::concurrency
uint16_t concurrency
Expected concurrency and number of shards.
Definition cache.h:194
fiftyoneDegreesCache::misses
unsigned long misses
The requests NOT served from the cache.
Definition cache.h:197
fiftyoneDegreesCache::nodes
fiftyoneDegreesCacheNode * nodes
Array of nodes / capacity.
Definition cache.h:193
fiftyoneDegreesCache::load
fiftyoneDegreesCacheLoadMethod load
Used by the cache to load an item into the cache.
Definition cache.h:198
fiftyoneDegreesCacheNode
Cache node structure used for storing data in the cache along with its key.
Definition cache.h:136
fiftyoneDegreesCacheNode::data
fiftyoneDegreesData data
Data contained in the node.
Definition cache.h:138
fiftyoneDegreesCacheNode::tree
fiftyoneDegreesTreeNode tree
Tree node for this cache node.
Definition cache.h:137
fiftyoneDegreesCacheNode::shard
fiftyoneDegreesCacheShard * shard
Shard the node is associated with.
Definition cache.h:139
fiftyoneDegreesCacheNode::listNext
fiftyoneDegreesCacheNode * listNext
Next node or NULL if last.
Definition cache.h:141
fiftyoneDegreesCacheNode::activeCount
int activeCount
Number of external references to the node data.
Definition cache.h:142
fiftyoneDegreesCacheNode::listPrevious
fiftyoneDegreesCacheNode * listPrevious
Previous node or NULL if first.
Definition cache.h:140
fiftyoneDegreesCacheShard
Cache shard structure used to enable concurrent access to the cache.
Definition cache.h:148
fiftyoneDegreesCacheShard::first
fiftyoneDegreesCacheNode * first
Pointer to the first node in the linked list.
Definition cache.h:155
fiftyoneDegreesCacheShard::lock
fiftyoneDegreesMutex lock
Used to ensure exclusive access to the shard for get and release operations.
Definition cache.h:160
fiftyoneDegreesCacheShard::cache
fiftyoneDegreesCache * cache
Pointer to the cache to which the node belongs.
Definition cache.h:149
fiftyoneDegreesCacheShard::allocated
uint32_t allocated
Number of nodes currently used in the shard.
Definition cache.h:153
fiftyoneDegreesCacheShard::last
fiftyoneDegreesCacheNode * last
Pointer to the last node in the linked list.
Definition cache.h:157
fiftyoneDegreesCacheShard::root
fiftyoneDegreesTreeRoot root
Root node of the red black tree.
Definition cache.h:151
fiftyoneDegreesCacheShard::capacity
uint32_t capacity
Capacity of the shard.
Definition cache.h:152
fiftyoneDegreesCacheShard::nodes
fiftyoneDegreesCacheNode * nodes
Pointer to the array of all nodes.
Definition cache.h:154
fiftyoneDegreesData
Data structure used for reusing memory which may have been allocated in a previous operation.
Definition data.h:105
fiftyoneDegreesException
Structure used to represent a 51Degrees exception and passed into methods that might generate excepti...
Definition exceptions.h:115
fiftyoneDegreesTreeNode
Node structure defining a single node in the tree.
Definition tree.h:81
fiftyoneDegreesTreeRoot
Tree root structure defining the beginning of the tree.
Definition tree.h:91

Have a data or code question? Get in touch and explore subscription options.