\r\n

51Degrees Device Detection C/C++  4.4

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 2023 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 
92 #ifndef FIFTYONE_DEGREES_CACHE_H_INCLUDED
93 #define FIFTYONE_DEGREES_CACHE_H_INCLUDED
94 
95 /* Define NDEBUG if needed, to ensure asserts are disabled in release builds */
96 #if !defined(DEBUG) && !defined(_DEBUG) && !defined(NDEBUG)
97 #define NDEBUG
98 #endif
99 
100 #include <stdint.h>
101 #include <stdbool.h>
102 
103 #ifdef _MSC_VER
104 #endif
105 #ifdef _MSC_VER
106 #pragma warning (push)
107 #pragma warning (disable: 5105)
108 #include <windows.h>
109 #pragma warning (default: 5105)
110 #pragma warning (pop)
111 #endif
112 #include <assert.h>
113 #include "data.h"
114 #include "exceptions.h"
115 #include "tree.h"
116 #include "common.h"
117 
118 #ifndef FIFTYONE_DEGREES_NO_THREADING
119 #include "threading.h"
120 #endif
121 
123 typedef struct fiftyone_degrees_cache_node_t fiftyoneDegreesCacheNode;
124 typedef struct fiftyone_degrees_cache_shard_t fiftyoneDegreesCacheShard;
125 typedef struct fiftyone_degrees_cache_t fiftyoneDegreesCache;
132 typedef struct fiftyone_degrees_cache_node_t {
133  fiftyoneDegreesTreeNode tree;
134  fiftyoneDegreesData data;
135  fiftyoneDegreesCacheShard *shard;
136  fiftyoneDegreesCacheNode *listPrevious;
137  fiftyoneDegreesCacheNode *listNext;
138  int activeCount;
139 } fiftyoneDegreesCacheNode;
140 
144 typedef struct fiftyone_degrees_cache_shard_t {
145  fiftyoneDegreesCache *cache;
147  fiftyoneDegreesTreeRoot root;
148  uint32_t capacity;
149  uint32_t allocated;
150  fiftyoneDegreesCacheNode *nodes;
151  fiftyoneDegreesCacheNode *first;
153  fiftyoneDegreesCacheNode *last;
155 #ifndef FIFTYONE_DEGREES_NO_THREADING
156  fiftyoneDegreesMutex lock;
158 #endif
159 } fiftyoneDegreesCacheShard;
160 
169 typedef void(*fiftyoneDegreesCacheLoadMethod)(
170  const void *state,
171  fiftyoneDegreesData *data,
172  const void *key,
173  fiftyoneDegreesException *exception);
174 
180 typedef int64_t(*fiftyoneDegreesCacheHashCodeMethod)(const void* key);
181 
187 typedef struct fiftyone_degrees_cache_t {
188  fiftyoneDegreesCacheShard *shards;
189  fiftyoneDegreesCacheNode *nodes;
190  uint16_t concurrency;
191  int32_t capacity;
192  unsigned long hits;
193  unsigned long misses;
194  fiftyoneDegreesCacheLoadMethod load;
196  fiftyoneDegreesCacheHashCodeMethod hash;
197  const void* loaderState;
198 } fiftyoneDegreesCache;
199 
210 EXTERNAL fiftyoneDegreesCache *fiftyoneDegreesCacheCreate(
211  uint32_t capacity,
212  uint16_t concurrency,
213  fiftyoneDegreesCacheLoadMethod load,
214  fiftyoneDegreesCacheHashCodeMethod hash,
215  const void *state);
216 
221 EXTERNAL void fiftyoneDegreesCacheFree(fiftyoneDegreesCache *cache);
222 
245 EXTERNAL fiftyoneDegreesCacheNode* fiftyoneDegreesCacheGet(
246  fiftyoneDegreesCache *cache,
247  const void *key,
248  fiftyoneDegreesException *exception);
249 
255 EXTERNAL void fiftyoneDegreesCacheRelease(fiftyoneDegreesCacheNode *node);
256 
264 EXTERNAL int64_t fiftyoneDegreesCacheHash32(const void *key);
265 
273 EXTERNAL int64_t fiftyoneDegreesCacheHash64(const void *key);
274 
278 #endif
fiftyoneDegreesCacheShard::capacity
uint32_t capacity
Capacity of the shard.
Definition: cache.h:148
fiftyoneDegreesCache::concurrency
uint16_t concurrency
Expected concurrency and number of shards.
Definition: cache.h:190
fiftyoneDegreesCache::capacity
int32_t capacity
Capacity of the cache.
Definition: cache.h:191
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 ...
fiftyoneDegreesCache::loaderState
const void * loaderState
Cache loader specific state.
Definition: cache.h:197
fiftyoneDegreesCache
Cache structure to store the root of the red black tree and a list of allocated cache nodes.
Definition: cache.h:187
fiftyoneDegreesMutex
pthread_mutex_t fiftyoneDegreesMutex
MUTEX AND THREADING MACROS.
Definition: threading.h:91
fiftyoneDegreesCache::shards
fiftyoneDegreesCacheShard * shards
Array of shards / concurrency.
Definition: cache.h:188
fiftyoneDegreesCache::nodes
fiftyoneDegreesCacheNode * nodes
Array of nodes / capacity.
Definition: cache.h:189
fiftyoneDegreesTreeRoot
Tree root structure defining the beginning of the tree.
Definition: tree.h:87
fiftyoneDegreesCacheShard::last
fiftyoneDegreesCacheNode * last
Pointer to the last node in the linked list.
Definition: cache.h:153
fiftyoneDegreesCacheNode::shard
fiftyoneDegreesCacheShard * shard
Shard the node is associated with.
Definition: cache.h:135
fiftyoneDegreesTreeNode
Node structure defining a single node in the tree.
Definition: tree.h:77
fiftyoneDegreesCacheNode
Cache node structure used for storing data in the cache along with its key.
Definition: cache.h:132
fiftyoneDegreesCache::hits
unsigned long hits
The requests served from the cache.
Definition: cache.h:192
fiftyoneDegreesCacheFree
void fiftyoneDegreesCacheFree(fiftyoneDegreesCache *cache)
Frees the cache structure, all allocated nodes and their data.
fiftyoneDegreesData
Data structure used for reusing memory which may have been allocated in a previous operation.
Definition: data.h:101
fiftyoneDegreesCacheHashCodeMethod
int64_t(* fiftyoneDegreesCacheHashCodeMethod)(const void *key)
Method used to calculate a hash code from the key.
Definition: cache.h:180
fiftyoneDegreesCacheShard::allocated
uint32_t allocated
Number of nodes currently used in the shard.
Definition: cache.h:149
fiftyoneDegreesCacheNode::activeCount
int activeCount
Number of external references to the node data.
Definition: cache.h:138
fiftyoneDegreesCacheShard::root
fiftyoneDegreesTreeRoot root
Root node of the red black tree.
Definition: cache.h:147
fiftyoneDegreesCacheShard::first
fiftyoneDegreesCacheNode * first
Pointer to the first node in the linked list.
Definition: cache.h:151
fiftyoneDegreesCacheShard::nodes
fiftyoneDegreesCacheNode * nodes
Pointer to the array of all nodes.
Definition: cache.h:150
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.
fiftyoneDegreesCacheShard::lock
fiftyoneDegreesMutex lock
Used to ensure exclusive access to the shard for get and release operations.
Definition: cache.h:156
fiftyoneDegreesCacheGet
fiftyoneDegreesCacheNode * fiftyoneDegreesCacheGet(fiftyoneDegreesCache *cache, const void *key, fiftyoneDegreesException *exception)
Gets an item from the cache.
fiftyoneDegreesCacheShard
Cache shard structure used to enable concurrent access to the cache.
Definition: cache.h:144
fiftyoneDegreesCacheNode::listPrevious
fiftyoneDegreesCacheNode * listPrevious
Previous node or NULL if first.
Definition: cache.h:136
fiftyoneDegreesCacheShard::cache
fiftyoneDegreesCache * cache
Pointer to the cache to which the node belongs.
Definition: cache.h:145
fiftyoneDegreesCacheNode::tree
fiftyoneDegreesTreeNode tree
Tree node for this cache node.
Definition: cache.h:133
fiftyoneDegreesException
Structure used to represent a 51Degrees exception and passed into methods that might generate excepti...
Definition: exceptions.h:111
fiftyoneDegreesCacheRelease
void fiftyoneDegreesCacheRelease(fiftyoneDegreesCacheNode *node)
Releases the cache node previous obtained via fiftyoneDegreesCacheGet so that it can be evicted from ...
fiftyoneDegreesCache::hash
fiftyoneDegreesCacheHashCodeMethod hash
Used to hash a key pointer.
Definition: cache.h:196
fiftyoneDegreesCache::misses
unsigned long misses
The requests NOT served from the cache.
Definition: cache.h:193
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 ...
fiftyoneDegreesCache::load
fiftyoneDegreesCacheLoadMethod load
Used by the cache to load an item into the cache.
Definition: cache.h:194
fiftyoneDegreesCacheLoadMethod
void(* fiftyoneDegreesCacheLoadMethod)(const void *state, fiftyoneDegreesData *data, const void *key, fiftyoneDegreesException *exception)
Method used to load data into the cache.
Definition: cache.h:169
fiftyoneDegreesCacheNode::listNext
fiftyoneDegreesCacheNode * listNext
Next node or NULL if last.
Definition: cache.h:137
fiftyoneDegreesCacheNode::data
fiftyoneDegreesData data
Data contained in the node.
Definition: cache.h:134

Generated by doxygen 1.8.15