cache.cpp@ 21848

Last change on this file since 21848 was 21337, checked in by vboxsync, 15 years ago
IPRT,HostDrv,AddDrv: Export public IPRT symbols for the linux kernel (pain).
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 9.5 KB

Line
1	/* $Id: cache.cpp 21337 2009-07-07 14:58:27Z vboxsync $ */
2	/** @file
3	* IPRT - Object cache
4	*/
5
6	/*
7	* Copyright (C) 2006-2007 Sun Microsystems, Inc.
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*
17	* The contents of this file may alternatively be used under the terms
18	* of the Common Development and Distribution License Version 1.0
19	* (CDDL) only, as it comes in the "COPYING.CDDL" file of the
20	* VirtualBox OSE distribution, in which case the provisions of the
21	* CDDL are applicable instead of those of the GPL.
22	*
23	* You may elect to license modified versions of this file under the
24	* terms and conditions of either the GPL or the CDDL or both.
25	*
26	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
27	* Clara, CA 95054 USA or visit http://www.sun.com if you need
28	* additional information or have any questions.
29	*/
30
31
32	/*******************************************************************************
33	* Header Files *
34	*******************************************************************************/
35	#include <iprt/cache.h>
36	#include "internal/iprt.h"
37
38	#include <iprt/cdefs.h>
39	#include <iprt/types.h>
40	#include <iprt/err.h>
41	#include <iprt/spinlock.h>
42	#include <iprt/mem.h>
43	#include <iprt/asm.h>
44
45	#include "internal/magics.h"
46
47
48	/**
49	* Create a cache for objects.
50	*
51	* @returns iprt status code.
52	* @param ppObjCache Where to store the pointer to the created cache.
53	* @param cElements Number of elements the cache can hold.
54	* 0 if unlimited size.
55	* @param cbElement Size of one element in bytes
56	* @param fProt Protection flags for protecting cache against concurrent access
57	* from different threads.
58	* RTOBJCACHE_PROTECT_REQUESTER to protect the request function.
59	* RTOBJCACHE_PROTECT_INSERT to protect the insert function.
60	*/
61	RTDECL(int) RTCacheCreate(PRTOBJCACHE *ppCache, uint32_t cElements, size_t cbElement, uint32_t fProt)
62	{
63	int rc = VINF_SUCCESS;
64	uint32_t cbCache = sizeof(RTOBJCACHE);
65
66	if ( RT_UNLIKELY(!VALID_PTR(ppCache))
67	\|\| !cbElement
68	\|\| (fProt & ~RTOBJCACHE_PROTECT_VALID))
69	return VERR_INVALID_PARAMETER;
70
71	if (cElements > 0)
72	cbCache += (cElements + 1) * sizeof(void ); / One slot is always free. */
73
74	PRTOBJCACHE pCacheNew = (PRTOBJCACHE)RTMemAllocZ(cbCache);
75	if (!pCacheNew)
76	return VERR_NO_MEMORY;
77
78	pCacheNew->cbObj = cbElement;
79	pCacheNew->cElements = cElements;
80	pCacheNew->SpinlockRequest = NIL_RTSPINLOCK;
81	pCacheNew->SpinlockInsert = NIL_RTSPINLOCK;
82	if (fProt & RTOBJCACHE_PROTECT_REQUEST)
83	{
84	rc = RTSpinlockCreate(&pCacheNew->SpinlockRequest);
85	if (RT_FAILURE(rc))
86	{
87	RTMemFree(pCacheNew);
88	return rc;
89	}
90	}
91
92	if (fProt & RTOBJCACHE_PROTECT_INSERT)
93	{
94	rc = RTSpinlockCreate(&pCacheNew->SpinlockInsert);
95	if (RT_FAILURE(rc))
96	{
97	if (pCacheNew->SpinlockRequest != NIL_RTSPINLOCK)
98	RTSpinlockDestroy(pCacheNew->SpinlockRequest);
99
100	RTMemFree(pCacheNew);
101	return rc;
102	}
103	}
104
105	/* Initialize array if cache is limited. */
106	if (pCacheNew->cElements > 0)
107	{
108	pCacheNew->u.defined.cElementsInCache = 0;
109	pCacheNew->u.defined.cNextObjRead = 0;
110	pCacheNew->u.defined.cNextFreeSlotWrite = 0;
111	}
112	else
113	{
114	/* Unlimited cache - Create dummy element. */
115	PRTOBJCACHEHDR pDummy = (PRTOBJCACHEHDR)RTMemAllocZ(sizeof(RTOBJCACHEHDR) + pCacheNew->cbObj);
116	if (!pDummy)
117	{
118	/* Cleanup. */
119	if (pCacheNew->SpinlockRequest != NIL_RTSPINLOCK)
120	RTSpinlockDestroy(pCacheNew->SpinlockRequest);
121
122	if (pCacheNew->SpinlockInsert != NIL_RTSPINLOCK)
123	RTSpinlockDestroy(pCacheNew->SpinlockInsert);
124
125	RTMemFree(pCacheNew);
126	return VERR_NO_MEMORY;
127	}
128
129	pDummy->uMagic = RTMEMCACHE_MAGIC;
130	pCacheNew->u.unlimited.pFirst = pDummy;
131	pCacheNew->u.unlimited.pLast = pDummy;
132	}
133
134	if (RT_SUCCESS(rc))
135	*ppCache = pCacheNew;
136
137	return rc;
138	}
139	RT_EXPORT_SYMBOL(RTCacheCreate);
140
141
142	/**
143	* Destroy a cache freeing allocated memory.
144	*
145	* @returns iprt status code.
146	* @param pCache Pointer to the cache.
147	*/
148	RTDECL(int) RTCacheDestroy(PRTOBJCACHE pCache)
149	{
150	if (pCache->SpinlockRequest != NIL_RTSPINLOCK)
151	RTSpinlockDestroy(pCache->SpinlockRequest);
152
153	if (pCache->SpinlockInsert != NIL_RTSPINLOCK)
154	RTSpinlockDestroy(pCache->SpinlockInsert);
155
156	/* Free all objects left in cache. */
157	if (pCache->cElements == 0)
158	{
159	volatile RTOBJCACHEHDR *pHdr = pCache->u.unlimited.pFirst;
160
161	while (pHdr)
162	{
163	volatile RTOBJCACHEHDR *pTemp = pHdr;
164
165	pHdr = pHdr->pNext;
166	RTMemFree((void *)pTemp);
167	}
168	}
169	else
170	{
171	while (pCache->u.defined.cNextObjRead != pCache->u.defined.cNextFreeSlotWrite)
172	{
173	if (pCache->u.defined.apObjCached[pCache->u.defined.cNextObjRead])
174	RTMemFree((void *)pCache->u.defined.apObjCached[pCache->u.defined.cNextObjRead]);
175	pCache->u.defined.cNextObjRead++;
176	pCache->u.defined.cNextObjRead &= pCache->cElements;
177	}
178	}
179
180	RTMemFree(pCache);
181
182	return VINF_SUCCESS;
183	}
184	RT_EXPORT_SYMBOL(RTCacheDestroy);
185
186
187	/**
188	* Request an object from the cache.
189	*
190	* @returns iprt status
191	* VERR_CACHE_EMPTY if cache is not unlimited and there is no object left in cache.
192	* @param pCache Pointer to the cache to get an object from.
193	* @param ppObj Where to store the pointer to the object.
194	*/
195	RTDECL(int) RTCacheRequest(PRTOBJCACHE pCache, void **ppObj)
196	{
197	RTSPINLOCKTMP spinlockTmp;
198
199	if (pCache->SpinlockRequest != NIL_RTSPINLOCK)
200	RTSpinlockAcquire(pCache->SpinlockRequest, &spinlockTmp);
201
202	if (pCache->cElements == 0)
203	{
204	if (pCache->u.unlimited.pFirst != pCache->u.unlimited.pLast)
205	{
206	volatile RTOBJCACHEHDR *pHdr = pCache->u.unlimited.pFirst;
207
208	pCache->u.unlimited.pFirst = pHdr->pNext;
209
210	if (pCache->SpinlockRequest != NIL_RTSPINLOCK)
211	RTSpinlockRelease(pCache->SpinlockRequest, &spinlockTmp);
212
213	pHdr->pNext = NULL;
214	ppObj = (uint8_t )pHdr + sizeof(RTOBJCACHEHDR);
215	}
216	else
217	{
218	/* We have to create a new cached object. - We can leave the spinlock safely here. */
219	if (pCache->SpinlockRequest != NIL_RTSPINLOCK)
220	RTSpinlockRelease(pCache->SpinlockRequest, &spinlockTmp);
221
222	PRTOBJCACHEHDR pObjNew = (PRTOBJCACHEHDR)RTMemAllocZ(sizeof(RTOBJCACHEHDR) + pCache->cbObj);
223	if (!pObjNew)
224	return VERR_NO_MEMORY;
225
226	pObjNew->uMagic = RTMEMCACHE_MAGIC;
227	ppObj = (uint8_t )pObjNew + sizeof(RTOBJCACHEHDR);
228	}
229	}
230	else
231	{
232	if (pCache->u.defined.cElementsInCache > 0)
233	{
234	ppObj = (void )pCache->u.defined.apObjCached[pCache->u.defined.cNextObjRead];
235	pCache->u.defined.cNextObjRead++;
236	pCache->u.defined.cNextObjRead &= pCache->cElements;
237	ASMAtomicDecU32((volatile uint32_t *)&pCache->u.defined.cElementsInCache);
238
239	if (pCache->SpinlockRequest != NIL_RTSPINLOCK)
240	RTSpinlockRelease(pCache->SpinlockRequest, &spinlockTmp);
241	}
242	else
243	{
244	if (pCache->SpinlockRequest != NIL_RTSPINLOCK)
245	RTSpinlockRelease(pCache->SpinlockRequest, &spinlockTmp);
246
247	return VERR_CACHE_EMPTY;
248	}
249	}
250
251	return VINF_SUCCESS;
252	}
253	RT_EXPORT_SYMBOL(RTCacheRequest);
254
255
256	/**
257	* Insert an object into the cache.
258	*
259	* @returns iprt status code.
260	* VERR_CACHE_FULL if cache is not unlimited and there is no free entry left in cache.
261	* @param pCache Pointer to the cache.
262	* @param pObj Pointer to the object to insert.
263	*/
264	RTDECL(int) RTCacheInsert(PRTOBJCACHE pCache, void *pObj)
265	{
266	RTSPINLOCKTMP spinlockTmp;
267	int rc = VINF_SUCCESS;
268
269	if (pCache->SpinlockInsert != NIL_RTSPINLOCK)
270	RTSpinlockAcquire(pCache->SpinlockInsert, &spinlockTmp);
271
272	if (pCache->cElements == 0)
273	{
274	PRTOBJCACHEHDR pHdr = (PRTOBJCACHEHDR)((uint8_t *)pObj - sizeof(RTOBJCACHEHDR));
275
276	AssertMsg(pHdr->uMagic == RTMEMCACHE_MAGIC, ("This is not a cached object\n"));
277
278	pCache->u.unlimited.pLast->pNext = pHdr;
279	pCache->u.unlimited.pLast = pHdr;
280	}
281	else
282	{
283	if (pCache->u.defined.cElementsInCache == pCache->cElements)
284	rc = VERR_CACHE_FULL;
285	else
286	{
287	pCache->u.defined.apObjCached[pCache->u.defined.cNextFreeSlotWrite] = pObj;
288	pCache->u.defined.cNextFreeSlotWrite++;
289	pCache->u.defined.cNextFreeSlotWrite &= pCache->cElements;
290	ASMAtomicIncU32((volatile uint32_t *)&pCache->u.defined.cElementsInCache);
291	}
292	}
293
294	if (pCache->SpinlockInsert != NIL_RTSPINLOCK)
295	RTSpinlockRelease(pCache->SpinlockInsert, &spinlockTmp);
296
297	return rc;
298	}
299	RT_EXPORT_SYMBOL(RTCacheInsert);
300

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Runtime/common/misc/cache.cpp@ 21848

Download in other formats: