Chameleon

Chameleon Svn Source Tree

Root/branches/chucko/i386/libsaio/cache.c

1/*
2 * Copyright (c) 2000-2003 Apple Computer, Inc. All rights reserved.
3 *
4 * @APPLE_LICENSE_HEADER_START@
5 *
6 * The contents of this file constitute Original Code as defined in and
7 * are subject to the Apple Public Source License Version 2.0 (the
8 * "License"). You may not use this file except in compliance with the
9 * License. Please obtain a copy of the License at
10 * http://www.apple.com/publicsource and read it before using this file.
11 *
12 * This Original Code and all software distributed under the License are
13 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17 * License for the specific language governing rights and limitations
18 * under the License.
19 *
20 * @APPLE_LICENSE_HEADER_END@
21 */
22/*
23 * cache.c - A simple cache for file systems meta-data.
24 *
25 * Copyright (c) 2000 Apple Computer, Inc.
26 *
27 * DRI: Josh de Cesare
28 */
29
30#include <sl.h>
31// #include <fs.h>
32
33struct CacheEntry {
34CICell ih;
35long time;
36long long offset;
37};
38typedef struct CacheEntry CacheEntry;
39
40#define kCacheSize (0x100000)
41#define kCacheMinBlockSize (0x200)
42#define kCacheMaxBlockSize (0x8000)
43#define kCacheMaxEntries (kCacheSize / kCacheMinBlockSize)
44
45static CICell gCacheIH;
46static long gCacheBlockSize;
47static long gCacheNumEntries;
48static long gCacheTime;
49
50#ifdef __i386__
51static CacheEntry *gCacheEntries;
52static char *gCacheBuffer;
53#else
54static CacheEntry gCacheEntries[kCacheMaxEntries];
55static char gCacheBuffer[kCacheSize];
56#endif
57
58#if CACHE_STATS
59unsigned long gCacheHits;
60unsigned long gCacheMisses;
61unsigned long gCacheEvicts;
62#endif
63
64void CacheReset()
65{
66gCacheIH = NULL;
67}
68
69void CacheInit( CICell ih, long blockSize )
70{
71#ifdef __i386__
72if ((ih == gCacheIH) && (blockSize == gCacheBlockSize))
73{
74return;
75}
76#endif
77
78if ((blockSize < kCacheMinBlockSize) || (blockSize > kCacheMaxBlockSize))
79{
80return;
81}
82
83gCacheBlockSize = blockSize;
84gCacheNumEntries = kCacheSize / gCacheBlockSize;
85gCacheTime = 0;
86
87#if CACHE_STATS
88gCacheHits= 0;
89gCacheMisses= 0;
90gCacheEvicts= 0;
91#endif
92
93 gCacheIH = ih;
94
95#ifdef __i386__
96if (!gCacheBuffer)
97{
98gCacheBuffer = (char *) malloc(kCacheSize);
99}
100
101if (!gCacheEntries)
102{
103gCacheEntries = (CacheEntry *) malloc(kCacheMaxEntries * sizeof(CacheEntry));
104}
105
106if (!gCacheBuffer || !gCacheEntries)
107{
108gCacheIH = 0; // invalidate cache
109return;
110}
111#endif
112
113bzero(gCacheEntries, kCacheMaxEntries * sizeof(CacheEntry));
114}
115
116long CacheRead(CICell ih, char * buffer, long long offset, long length, long cache)
117{
118long cnt, oldestEntry = 0, oldestTime, loadCache = 0;
119CacheEntry *entry;
120
121// See if the data can be cached.
122if (cache && (gCacheIH == ih) && (length == gCacheBlockSize))
123{
124// Look for the data in the cache.
125for (cnt = 0; cnt < gCacheNumEntries; cnt++)
126{
127entry = &gCacheEntries[cnt];
128
129if ((entry->ih == ih) && (entry->offset == offset))
130{
131entry->time = ++gCacheTime;
132break;
133}
134}
135
136// If the data was found copy it to the caller.
137if (cnt != gCacheNumEntries)
138{
139bcopy(gCacheBuffer + cnt * gCacheBlockSize, buffer, gCacheBlockSize);
140#if CACHE_STATS
141gCacheHits++;
142#endif
143return gCacheBlockSize;
144}
145
146// Could not find the data in the cache.
147loadCache = 1;
148}
149
150// Read the data from the disk.
151Seek(ih, offset);
152Read(ih, (long)buffer, length);
153
154#if CACHE_STATS
155if (cache)
156{
157gCacheMisses++;
158}
159#endif
160
161// Put the data from the disk in the cache if needed.
162if (loadCache)
163{
164// Find a free entry.
165oldestTime = gCacheTime;
166
167for (cnt = 0; cnt < gCacheNumEntries; cnt++)
168{
169entry = &gCacheEntries[cnt];
170
171// Found a free entry.
172if (entry->ih == 0)
173{
174break;
175}
176
177if (entry->time < oldestTime)
178{
179oldestTime = entry->time;
180oldestEntry = cnt;
181}
182}
183
184// If no free entry was found, use the oldest.
185if (cnt == gCacheNumEntries)
186{
187cnt = oldestEntry;
188#if CACHE_STATS
189gCacheEvicts++;
190#endif
191}
192
193// Copy the data from disk to the new entry.
194entry = &gCacheEntries[cnt];
195entry->ih = ih;
196entry->time = ++gCacheTime;
197entry->offset = offset;
198bcopy(buffer, gCacheBuffer + cnt * gCacheBlockSize, gCacheBlockSize);
199}
200
201return length;
202}
203

Archive Download this file

Revision: 2329