comparison src/xgccache.c @ 2587:1e2a3710564c

[xemacs-hg @ 2005-02-15 03:17:07 by ben] Put back mistakenly deleted files
author ben
date Tue, 15 Feb 2005 03:17:08 +0000
parents
children ad2f4ae9895b
comparison
equal deleted inserted replaced
2586:196ee3cd1ac5 2587:1e2a3710564c
1 /* Efficient caching of X GCs (graphics contexts).
2 Copyright (C) 1993 Free Software Foundation, Inc.
3 Copyright (C) 1994, 1995 Board of Trustees, University of Illinois.
4
5 This file is part of XEmacs.
6
7 XEmacs is free software; you can redistribute it and/or modify it
8 under the terms of the GNU General Public License as published by the
9 Free Software Foundation; either version 2, or (at your option) any
10 later version.
11
12 XEmacs is distributed in the hope that it will be useful, but WITHOUT
13 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15 for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with XEmacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 /* Synched up with: Not in FSF. */
23
24 /* Emacs uses a lot of different display attributes; for example, assume
25 that only four fonts are in use (normal, bold, italic, and bold-italic).
26 Then assume that one stipple or background is used for text selections,
27 and another is used for highlighting mousable regions. That makes 16
28 GCs already. Add in the fact that another GC may be needed to display
29 the text cursor in any of those regions, and you've got 32. Add in
30 more fonts, and it keeps increasing exponentially.
31
32 We used to keep these GCs in a cache of merged (fully qualified) faces.
33 However, a lot of other code in xterm.c used XChangeGC of existing GCs,
34 which is kind of slow and kind of random. Also, managing the face cache
35 was tricky because it was hard to know when a face was no longer visible
36 on the frame -- we had to mark all frames as garbaged whenever a face
37 was changed, which caused an unpleasant amount of flicker (since faces are
38 created/destroyed (= changed) whenever a frame is created/destroyed.
39
40 So this code maintains a cache at the GC level instead of at the face
41 level. There is an upper limit on the size of the cache, after which we
42 will stop creating GCs and start reusing them (reusing the least-recently-
43 used ones first). So if faces get changed, their GCs will eventually be
44 recycled. Also more sharing of GCs is possible.
45
46 This code uses hash tables. It could be that, if the cache size is small
47 enough, a linear search might be faster; but I doubt it, since we need
48 `equal' comparisons, not `eq', and I expect that the optimal cache size
49 will be ~100.
50
51 Written by jwz, 14 jun 93
52 */
53
54 #include <config.h>
55 #include <X11/Xlib.h>
56 #include "xgccache.h"
57
58
59 #define GC_CACHE_SIZE 100
60
61 #define GCCACHE_HASH
62
63
64 #ifdef GCCACHE_HASH
65 #include "lisp.h"
66 #include "hash.h"
67 #endif
68
69 struct gcv_and_mask {
70 XGCValues gcv;
71 unsigned long mask;
72 };
73
74 struct gc_cache_cell {
75 GC gc;
76 struct gcv_and_mask gcvm;
77 struct gc_cache_cell *prev, *next;
78 };
79
80 struct gc_cache {
81 Display *dpy; /* used only as arg to XCreateGC/XFreeGC */
82 Window window; /* used only as arg to XCreateGC */
83 int size;
84 struct gc_cache_cell *head;
85 struct gc_cache_cell *tail;
86 #ifdef GCCACHE_HASH
87 struct hash_table *table;
88 #endif
89
90 int create_count;
91 int delete_count;
92 };
93
94 #ifdef GCCACHE_HASH
95 static Hashcode
96 gc_cache_hash (const void *arg)
97 {
98 const struct gcv_and_mask *gcvm = (const struct gcv_and_mask *) arg;
99 unsigned long *longs = (unsigned long *) &gcvm->gcv;
100 Hashcode hash = gcvm->mask;
101 int i;
102 /* This could look at the mask and only use the used slots in the
103 hash code. That would win in that we wouldn't have to initialize
104 every slot of the gcv when calling gc_cache_lookup. But we need
105 the hash function to be as fast as possible; some timings should
106 be done. */
107 for (i = 0; i < (int) (sizeof (XGCValues) / sizeof (unsigned long)); i++)
108 hash = (hash << 1) ^ *longs++;
109 return hash;
110 }
111
112 #endif /* GCCACHE_HASH */
113
114 static int
115 gc_cache_eql (const void *arg1, const void *arg2)
116 {
117 /* See comment in gc_cache_hash */
118 return !memcmp (arg1, arg2, sizeof (struct gcv_and_mask));
119 }
120
121 struct gc_cache *
122 make_gc_cache (Display *dpy, Window window)
123 {
124 struct gc_cache *cache = xnew (struct gc_cache);
125 cache->dpy = dpy;
126 cache->window = window;
127 cache->size = 0;
128 cache->head = cache->tail = 0;
129 cache->create_count = cache->delete_count = 0;
130 #ifdef GCCACHE_HASH
131 cache->table =
132 make_general_hash_table (GC_CACHE_SIZE, gc_cache_hash, gc_cache_eql);
133 #endif
134 return cache;
135 }
136
137 void
138 free_gc_cache (struct gc_cache *cache)
139 {
140 struct gc_cache_cell *rest, *next;
141 rest = cache->head;
142 while (rest)
143 {
144 XFreeGC (cache->dpy, rest->gc);
145 next = rest->next;
146 xfree (rest, struct gc_cache_cell *);
147 rest = next;
148 }
149 #ifdef GCCACHE_HASH
150 free_hash_table (cache->table);
151 #endif
152 xfree (cache, struct gc_cache *);
153 }
154
155 GC
156 gc_cache_lookup (struct gc_cache *cache, XGCValues *gcv, unsigned long mask)
157 {
158 struct gc_cache_cell *cell, *next, *prev;
159 struct gcv_and_mask gcvm;
160
161 if ((!!cache->head) != (!!cache->tail)) ABORT ();
162 if (cache->head && (cache->head->prev || cache->tail->next)) ABORT ();
163
164 gcvm.mask = mask;
165 gcvm.gcv = *gcv; /* this copies... */
166
167 #ifdef GCCACHE_HASH
168
169 /* The intermediate cast fools gcc into not outputting strict-aliasing
170 complaints */
171 if (gethash (&gcvm, cache->table, (const void **) (void *) &cell))
172
173 #else /* !GCCACHE_HASH */
174
175 cell = cache->tail; /* start at the end (most recently used) */
176 while (cell)
177 {
178 if (gc_cache_eql (&gcvm, &cell->gcvm))
179 break;
180 else
181 cell = cell->prev;
182 }
183
184 /* #### This whole file needs some serious overhauling. */
185 if (!(mask | GCTile) && cell->gc->values.tile)
186 cell = 0;
187 else if (!(mask | GCStipple) && cell->gc->values.stipple)
188 cell = 0;
189
190 if (cell)
191
192 #endif /* !GCCACHE_HASH */
193
194 {
195 /* Found a cell. Move this cell to the end of the list, so that it
196 will be less likely to be collected than a cell that was accessed
197 less recently.
198 */
199 if (cell == cache->tail)
200 return cell->gc;
201
202 next = cell->next;
203 prev = cell->prev;
204 if (prev) prev->next = next;
205 if (next) next->prev = prev;
206 if (cache->head == cell) cache->head = next;
207 cell->next = 0;
208 cell->prev = cache->tail;
209 cache->tail->next = cell;
210 cache->tail = cell;
211 if (cache->head == cell) ABORT ();
212 if (cell->next) ABORT ();
213 if (cache->head->prev) ABORT ();
214 if (cache->tail->next) ABORT ();
215 return cell->gc;
216 }
217
218 /* else, cache miss. */
219
220 if (cache->size == GC_CACHE_SIZE)
221 /* Reuse the first cell on the list (least-recently-used).
222 Remove it from the list, and unhash it from the table.
223 */
224 {
225 cell = cache->head;
226 cache->head = cell->next;
227 cache->head->prev = 0;
228 if (cache->tail == cell) cache->tail = 0; /* only one */
229 XFreeGC (cache->dpy, cell->gc);
230 cache->delete_count++;
231 #ifdef GCCACHE_HASH
232 remhash (&cell->gcvm, cache->table);
233 #endif
234 }
235 else if (cache->size > GC_CACHE_SIZE)
236 ABORT ();
237 else
238 {
239 /* Allocate a new cell (don't put it in the list or table yet). */
240 cell = xnew (struct gc_cache_cell);
241 cache->size++;
242 }
243
244 /* Now we've got a cell (new or reused). Fill it in. */
245 memcpy (&cell->gcvm.gcv, gcv, sizeof (XGCValues));
246 cell->gcvm.mask = mask;
247
248 /* Put the cell on the end of the list. */
249 cell->next = 0;
250 cell->prev = cache->tail;
251 if (cache->tail) cache->tail->next = cell;
252 cache->tail = cell;
253 if (! cache->head) cache->head = cell;
254
255 cache->create_count++;
256 #ifdef GCCACHE_HASH
257 /* Hash it in the table */
258 puthash (&cell->gcvm, cell, cache->table);
259 #endif
260
261 /* Now make and return the GC. */
262 cell->gc = XCreateGC (cache->dpy, cache->window, mask, gcv);
263
264 /* debug */
265 assert (cell->gc == gc_cache_lookup (cache, gcv, mask));
266
267 return cell->gc;
268 }
269
270
271 #ifdef DEBUG_XEMACS
272
273 void describe_gc_cache (struct gc_cache *cache);
274 void
275 describe_gc_cache (struct gc_cache *cache)
276 {
277 int count = 0;
278 struct gc_cache_cell *cell = cache->head;
279 stderr_out ("\nsize: %d", cache->size);
280 stderr_out ("\ncreated: %d", cache->create_count);
281 stderr_out ("\ndeleted: %d", cache->delete_count);
282 while (cell)
283 {
284 struct gc_cache_cell *cell2;
285 int i = 0;
286 stderr_out ("\n%d:\t0x%lx GC: 0x%08lx hash: 0x%08lx\n",
287 count, (long) cell, (long) cell->gc, gc_cache_hash (&cell->gcvm));
288 for (cell2 = cache->head; cell2; cell2 = cell2->next, i++)
289 if (count != i &&
290 gc_cache_hash (&cell->gcvm) == gc_cache_hash (&cell2->gcvm))
291 stderr_out ("\tHASH COLLISION with cell %d\n", i);
292 stderr_out ("\tmask: %8lx\n", cell->gcvm.mask);
293
294 #define FROB(field) do { \
295 if ((int)cell->gcvm.gcv.field != (~0)) \
296 stderr_out ("\t%-12s%8x\n", #field ":", (int)cell->gcvm.gcv.field); \
297 } while (0)
298 FROB (function);
299 FROB (plane_mask);
300 FROB (foreground);
301 FROB (background);
302 FROB (line_width);
303 FROB (line_style);
304 FROB (cap_style);
305 FROB (join_style);
306 FROB (fill_style);
307 FROB (fill_rule);
308 FROB (arc_mode);
309 FROB (tile);
310 FROB (stipple);
311 FROB (ts_x_origin);
312 FROB (ts_y_origin);
313 FROB (font);
314 FROB (subwindow_mode);
315 FROB (graphics_exposures);
316 FROB (clip_x_origin);
317 FROB (clip_y_origin);
318 FROB (clip_mask);
319 FROB (dash_offset);
320 #undef FROB
321
322 count++;
323 if (cell->next && cell == cache->tail)
324 stderr_out ("\nERROR! tail is here!\n\n");
325 else if (!cell->next && cell != cache->tail)
326 stderr_out ("\nERROR! tail is not at the end\n\n");
327 cell = cell->next;
328 }
329 if (count != cache->size)
330 stderr_out ("\nERROR! count should be %d\n\n", cache->size);
331 }
332
333 #endif /* DEBUG_XEMACS */