\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 2022 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 {
140 
144 typedef struct fiftyone_degrees_cache_shard_t {
148  uint32_t capacity;
149  uint32_t allocated;
155 #ifndef FIFTYONE_DEGREES_NO_THREADING
158 #endif
160 
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 {
190  uint16_t concurrency;
191  int32_t capacity;
192  unsigned long hits;
193  unsigned long misses;
197  const void* loaderState;
199 
211  uint32_t capacity,
212  uint16_t concurrency,
215  const void *state);
216 
221 EXTERNAL void fiftyoneDegreesCacheFree(fiftyoneDegreesCache *cache);
222 
246  fiftyoneDegreesCache *cache,
247  const void *key,
248  fiftyoneDegreesException *exception);
249 
256 
264 EXTERNAL int64_t fiftyoneDegreesCacheHash32(const void *key);
265 
273 EXTERNAL int64_t fiftyoneDegreesCacheHash64(const void *key);
274 
278 #endif
uint32_t capacity
Capacity of the shard.
Definition: cache.h:148
uint16_t concurrency
Expected concurrency and number of shards.
Definition: cache.h:190
int32_t capacity
Capacity of the cache.
Definition: cache.h:191
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 ...
const void * loaderState
Cache loader specific state.
Definition: cache.h:197
Cache structure to store the root of the red black tree and a list of allocated cache nodes.
Definition: cache.h:187
pthread_mutex_t fiftyoneDegreesMutex
MUTEX AND THREADING MACROS.
Definition: threading.h:91
fiftyoneDegreesCacheShard * shards
Array of shards / concurrency.
Definition: cache.h:188
fiftyoneDegreesCacheNode * nodes
Array of nodes / capacity.
Definition: cache.h:189
Tree root structure defining the beginning of the tree.
Definition: tree.h:87
fiftyoneDegreesCacheNode * last
Pointer to the last node in the linked list.
Definition: cache.h:153
fiftyoneDegreesCacheShard * shard
Shard the node is associated with.
Definition: cache.h:135
Node structure defining a single node in the tree.
Definition: tree.h:77
Cache node structure used for storing data in the cache along with its key.
Definition: cache.h:132
unsigned long hits
The requests served from the cache.
Definition: cache.h:192
void fiftyoneDegreesCacheFree(fiftyoneDegreesCache *cache)
Frees the cache structure, all allocated nodes and their data.
Data structure used for reusing memory which may have been allocated in a previous operation.
Definition: data.h:101
int64_t(* fiftyoneDegreesCacheHashCodeMethod)(const void *key)
Method used to calculate a hash code from the key.
Definition: cache.h:180
uint32_t allocated
Number of nodes currently used in the shard.
Definition: cache.h:149
int activeCount
Number of external references to the node data.
Definition: cache.h:138
fiftyoneDegreesTreeRoot root
Root node of the red black tree.
Definition: cache.h:147
fiftyoneDegreesCacheNode * first
Pointer to the first node in the linked list.
Definition: cache.h:151
fiftyoneDegreesCacheNode * nodes
Pointer to the array of all nodes.
Definition: cache.h:150
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.
fiftyoneDegreesMutex lock
Used to ensure exclusive access to the shard for get and release operations.
Definition: cache.h:156
fiftyoneDegreesCacheNode * fiftyoneDegreesCacheGet(fiftyoneDegreesCache *cache, const void *key, fiftyoneDegreesException *exception)
Gets an item from the cache.
Cache shard structure used to enable concurrent access to the cache.
Definition: cache.h:144
fiftyoneDegreesCacheNode * listPrevious
Previous node or NULL if first.
Definition: cache.h:136
fiftyoneDegreesCache * cache
Pointer to the cache to which the node belongs.
Definition: cache.h:145
fiftyoneDegreesTreeNode tree
Tree node for this cache node.
Definition: cache.h:133
Structure used to represent a 51Degrees exception and passed into methods that might generate excepti...
Definition: exceptions.h:111
void fiftyoneDegreesCacheRelease(fiftyoneDegreesCacheNode *node)
Releases the cache node previous obtained via fiftyoneDegreesCacheGet so that it can be evicted from ...
fiftyoneDegreesCacheHashCodeMethod hash
Used to hash a key pointer.
Definition: cache.h:196
unsigned long misses
The requests NOT served from the cache.
Definition: cache.h:193
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 ...
fiftyoneDegreesCacheLoadMethod load
Used by the cache to load an item into the cache.
Definition: cache.h:194
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
Next node or NULL if last.
Definition: cache.h:137
fiftyoneDegreesData data
Data contained in the node.
Definition: cache.h:134