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.
5 This file is part of XEmacs.
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
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
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. */
22 /* Synched up with: Not in FSF. */
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.
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.
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.
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
51 Written by jwz, 14 jun 93
59 #define GC_CACHE_SIZE 100
74 struct gc_cache_cell {
76 struct gcv_and_mask gcvm;
77 struct gc_cache_cell *prev, *next;
81 Display *dpy; /* used only as arg to XCreateGC/XFreeGC */
82 Window window; /* used only as arg to XCreateGC */
84 struct gc_cache_cell *head;
85 struct gc_cache_cell *tail;
87 struct hash_table *table;
96 gc_cache_hash (const void *arg)
98 const struct gcv_and_mask *gcvm = (const struct gcv_and_mask *) arg;
99 unsigned long *longs = (unsigned long *) &gcvm->gcv;
100 unsigned long hash = gcvm->mask;
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
107 for (i = 0; i < (sizeof (XGCValues) / sizeof (unsigned long)); i++)
108 hash = (hash<<1) ^ *longs++;
112 #endif /* GCCACHE_HASH */
115 gc_cache_eql (const void *arg1, const void *arg2)
117 /* See comment in gc_cache_hash */
118 return !memcmp (arg1, arg2, sizeof (struct gcv_and_mask));
122 make_gc_cache (Display *dpy, Window window)
124 struct gc_cache *cache = xnew (struct gc_cache);
126 cache->window = window;
128 cache->head = cache->tail = 0;
129 cache->create_count = cache->delete_count = 0;
132 make_general_hash_table (GC_CACHE_SIZE, gc_cache_hash, gc_cache_eql);
138 free_gc_cache (struct gc_cache *cache)
140 struct gc_cache_cell *rest, *next;
144 XFreeGC (cache->dpy, rest->gc);
150 free_hash_table (cache->table);
156 gc_cache_lookup (struct gc_cache *cache, XGCValues *gcv, unsigned long mask)
158 struct gc_cache_cell *cell, *next, *prev;
159 struct gcv_and_mask gcvm;
161 if ((!!cache->head) != (!!cache->tail)) ABORT ();
162 if (cache->head && (cache->head->prev || cache->tail->next)) ABORT ();
165 gcvm.gcv = *gcv; /* this copies... */
169 if (gethash (&gcvm, cache->table, (const void **) &cell))
171 #else /* !GCCACHE_HASH */
173 cell = cache->tail; /* start at the end (most recently used) */
176 if (gc_cache_eql (&gcvm, &cell->gcvm))
182 /* #### This whole file needs some serious overhauling. */
183 if (!(mask | GCTile) && cell->gc->values.tile)
185 else if (!(mask | GCStipple) && cell->gc->values.stipple)
190 #endif /* !GCCACHE_HASH */
193 /* Found a cell. Move this cell to the end of the list, so that it
194 will be less likely to be collected than a cell that was accessed
197 if (cell == cache->tail)
202 if (prev) prev->next = next;
203 if (next) next->prev = prev;
204 if (cache->head == cell) cache->head = next;
206 cell->prev = cache->tail;
207 cache->tail->next = cell;
209 if (cache->head == cell) ABORT ();
210 if (cell->next) ABORT ();
211 if (cache->head->prev) ABORT ();
212 if (cache->tail->next) ABORT ();
216 /* else, cache miss. */
218 if (cache->size == GC_CACHE_SIZE)
219 /* Reuse the first cell on the list (least-recently-used).
220 Remove it from the list, and unhash it from the table.
224 cache->head = cell->next;
225 cache->head->prev = 0;
226 if (cache->tail == cell) cache->tail = 0; /* only one */
227 XFreeGC (cache->dpy, cell->gc);
228 cache->delete_count++;
230 remhash (&cell->gcvm, cache->table);
233 else if (cache->size > GC_CACHE_SIZE)
237 /* Allocate a new cell (don't put it in the list or table yet). */
238 cell = xnew (struct gc_cache_cell);
242 /* Now we've got a cell (new or reused). Fill it in. */
243 memcpy (&cell->gcvm.gcv, gcv, sizeof (XGCValues));
244 cell->gcvm.mask = mask;
246 /* Put the cell on the end of the list. */
248 cell->prev = cache->tail;
249 if (cache->tail) cache->tail->next = cell;
251 if (! cache->head) cache->head = cell;
253 cache->create_count++;
255 /* Hash it in the table */
256 puthash (&cell->gcvm, cell, cache->table);
259 /* Now make and return the GC. */
260 cell->gc = XCreateGC (cache->dpy, cache->window, mask, gcv);
263 assert (cell->gc == gc_cache_lookup (cache, gcv, mask));
271 void describe_gc_cache (struct gc_cache *cache);
273 describe_gc_cache (struct gc_cache *cache)
276 struct gc_cache_cell *cell = cache->head;
277 stderr_out ("\nsize: %d", cache->size);
278 stderr_out ("\ncreated: %d", cache->create_count);
279 stderr_out ("\ndeleted: %d", cache->delete_count);
282 struct gc_cache_cell *cell2;
284 stderr_out ("\n%d:\t0x%lx GC: 0x%08lx hash: 0x%08lx\n",
285 count, (long) cell, (long) cell->gc, gc_cache_hash (&cell->gcvm));
286 for (cell2 = cache->head; cell2; cell2 = cell2->next, i++)
288 gc_cache_hash (&cell->gcvm) == gc_cache_hash (&cell2->gcvm))
289 stderr_out ("\tHASH COLLISION with cell %d\n", i);
290 stderr_out ("\tmask: %8lx\n", cell->gcvm.mask);
292 #define FROB(field) do { \
293 if ((int)cell->gcvm.gcv.field != (~0)) \
294 stderr_out ("\t%-12s%8x\n", #field ":", (int)cell->gcvm.gcv.field); \
312 FROB (subwindow_mode);
313 FROB (graphics_exposures);
314 FROB (clip_x_origin);
315 FROB (clip_y_origin);
321 if (cell->next && cell == cache->tail)
322 stderr_out ("\nERROR! tail is here!\n\n");
323 else if (!cell->next && cell != cache->tail)
324 stderr_out ("\nERROR! tail is not at the end\n\n");
327 if (count != cache->size)
328 stderr_out ("\nERROR! count should be %d\n\n", cache->size);
331 #endif /* DEBUG_XEMACS */