\r\n

51Degrees Device Detection C/C++  4.3

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 2019 51 Degrees Mobile Experts Limited, 5 Charlotte Close,
4  * Caversham, Reading, Berkshire, United Kingdom RG4 7BY.
5  *
6  * This Original Work is licensed under the European Union Public Licence (EUPL)
7  * 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 
117 #ifndef FIFTYONE_DEGREES_NO_THREADING
118 #include "threading.h"
119 #endif
120 
121 #ifdef __cplusplus
122 #define EXTERNAL extern "C"
123 #else
124 #define EXTERNAL
125 #endif
126 
128 typedef struct fiftyone_degrees_cache_node_t fiftyoneDegreesCacheNode;
129 typedef struct fiftyone_degrees_cache_shard_t fiftyoneDegreesCacheShard;
130 typedef struct fiftyone_degrees_cache_t fiftyoneDegreesCache;
137 typedef struct fiftyone_degrees_cache_node_t {
145 
149 typedef struct fiftyone_degrees_cache_shard_t {
153  uint32_t capacity;
154  uint32_t allocated;
160 #ifndef FIFTYONE_DEGREES_NO_THREADING
163 #endif
165 
175  const void *state,
176  fiftyoneDegreesData *data,
177  const void *key,
178  fiftyoneDegreesException *exception);
179 
185 typedef int64_t(*fiftyoneDegreesCacheHashCodeMethod)(const void* key);
186 
192 typedef struct fiftyone_degrees_cache_t {
195  uint16_t concurrency;
196  int32_t capacity;
197  unsigned long hits;
198  unsigned long misses;
202  const void* loaderState;
204 
216  uint32_t capacity,
217  uint16_t concurrency,
220  const void *state);
221 
226 EXTERNAL void fiftyoneDegreesCacheFree(fiftyoneDegreesCache *cache);
227 
251  fiftyoneDegreesCache *cache,
252  const void *key,
253  fiftyoneDegreesException *exception);
254 
261 
269 EXTERNAL int64_t fiftyoneDegreesCacheHash32(const void *key);
270 
278 EXTERNAL int64_t fiftyoneDegreesCacheHash64(const void *key);
279 
283 #endif
uint32_t capacity
Capacity of the shard.
Definition: cache.h:153
uint16_t concurrency
Expected concurrency and number of shards.
Definition: cache.h:195
int32_t capacity
Capacity of the cache.
Definition: cache.h:196
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:202
Cache structure to store the root of the red black tree and a list of allocated cache nodes.
Definition: cache.h:192
pthread_mutex_t fiftyoneDegreesMutex
MUTEX AND THREADING MACROS.
Definition: threading.h:96
fiftyoneDegreesCacheShard * shards
Array of shards / concurrency.
Definition: cache.h:193
fiftyoneDegreesCacheNode * nodes
Array of nodes / capacity.
Definition: cache.h:194
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:158
fiftyoneDegreesCacheShard * shard
Shard the node is associated with.
Definition: cache.h:140
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:137
unsigned long hits
The requests served from the cache.
Definition: cache.h:197
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:106
int64_t(* fiftyoneDegreesCacheHashCodeMethod)(const void *key)
Method used to calculate a hash code from the key.
Definition: cache.h:185
uint32_t allocated
Number of nodes currently used in the shard.
Definition: cache.h:154
int activeCount
Number of external references to the node data.
Definition: cache.h:143
fiftyoneDegreesTreeRoot root
Root node of the red black tree.
Definition: cache.h:152
fiftyoneDegreesCacheNode * first
Pointer to the first node in the linked list.
Definition: cache.h:156
fiftyoneDegreesCacheNode * nodes
Pointer to the array of all nodes.
Definition: cache.h:155
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:161
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:149
fiftyoneDegreesCacheNode * listPrevious
Previous node or NULL if first.
Definition: cache.h:141
fiftyoneDegreesCache * cache
Pointer to the cache to which the node belongs.
Definition: cache.h:150
fiftyoneDegreesTreeNode tree
Tree node for this cache node.
Definition: cache.h:138
Structure used to represent a 51Degrees exception and passed into methods that might generate excepti...
Definition: exceptions.h:116
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:201
unsigned long misses
The requests NOT served from the cache.
Definition: cache.h:198
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:199
void(* fiftyoneDegreesCacheLoadMethod)(const void *state, fiftyoneDegreesData *data, const void *key, fiftyoneDegreesException *exception)
Method used to load data into the cache.
Definition: cache.h:174
fiftyoneDegreesCacheNode * listNext
Next node or NULL if last.
Definition: cache.h:142
fiftyoneDegreesData data
Data contained in the node.
Definition: cache.h:139