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 SXEmacs
7 SXEmacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 SXEmacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Synched up with: Not in FSF. */
23 /* Emacs uses a lot of different display attributes; for example, assume
24 that only four fonts are in use (normal, bold, italic, and bold-italic).
25 Then assume that one stipple or background is used for text selections,
26 and another is used for highlighting mousable regions. That makes 16
27 GCs already. Add in the fact that another GC may be needed to display
28 the text cursor in any of those regions, and you've got 32. Add in
29 more fonts, and it keeps increasing exponentially.
31 We used to keep these GCs in a cache of merged (fully qualified) faces.
32 However, a lot of other code in xterm.c used XChangeGC of existing GCs,
33 which is kind of slow and kind of random. Also, managing the face cache
34 was tricky because it was hard to know when a face was no longer visible
35 on the frame -- we had to mark all frames as garbaged whenever a face
36 was changed, which caused an unpleasant amount of flicker (since faces are
37 created/destroyed (= changed) whenever a frame is created/destroyed.
39 So this code maintains a cache at the GC level instead of at the face
40 level. There is an upper limit on the size of the cache, after which we
41 will stop creating GCs and start reusing them (reusing the least-recently-
42 used ones first). So if faces get changed, their GCs will eventually be
43 recycled. Also more sharing of GCs is possible.
45 This code uses hash tables. It could be that, if the cache size is small
46 enough, a linear search might be faster; but I doubt it, since we need
47 `equal' comparisons, not `eq', and I expect that the optimal cache size
50 Written by jwz, 14 jun 93
57 #define GC_CACHE_SIZE 100
71 struct gc_cache_cell {
73 struct gcv_and_mask gcvm;
74 struct gc_cache_cell *prev, *next;
78 Display *dpy; /* used only as arg to XCreateGC/XFreeGC */
79 Window window; /* used only as arg to XCreateGC */
81 struct gc_cache_cell *head;
82 struct gc_cache_cell *tail;
84 struct hash_table *table;
92 static long unsigned int
93 gc_cache_hash(const void *arg)
95 const struct gcv_and_mask *gcvm = (const struct gcv_and_mask *)arg;
96 const long unsigned int *longs = (const long unsigned int*)&gcvm->gcv;
97 long unsigned int hash = gcvm->mask;
99 /* This could look at the mask and only use the used slots in the
100 hash code. That would win in that we wouldn't have to initialize
101 every slot of the gcv when calling gc_cache_lookup. But we need
102 the hash function to be as fast as possible; some timings should
104 for (i = 0; i < (sizeof(XGCValues) / sizeof(long unsigned int)); i++) {
105 hash = (hash << 1) ^ *longs++;
110 #endif /* GCCACHE_HASH */
112 static int gc_cache_eql(const void *arg1, const void *arg2)
114 /* See comment in gc_cache_hash */
115 return !memcmp(arg1, arg2, sizeof(struct gcv_and_mask));
118 struct gc_cache *make_gc_cache(Display * dpy, Window window)
120 struct gc_cache *cache = xnew(struct gc_cache);
122 cache->window = window;
124 cache->head = cache->tail = 0;
125 cache->create_count = cache->delete_count = 0;
128 make_general_hash_table(GC_CACHE_SIZE, gc_cache_hash, gc_cache_eql);
133 void free_gc_cache(struct gc_cache *volatile cache)
135 struct gc_cache_cell *volatile rest, *volatile next;
138 XFreeGC(cache->dpy, rest->gc);
144 free_hash_table(cache->table);
149 GC gc_cache_lookup(struct gc_cache *cache, XGCValues * gcv, unsigned long mask)
151 struct gc_cache_cell *cell = NULL, *next = NULL, *prev = NULL;
152 struct gcv_and_mask gcvm;
156 else if ((!!cache->head) != (!!cache->tail))
158 else if (cache->head && cache->tail && (cache->head->prev || cache->tail->next))
162 gcvm.gcv = *gcv; /* this copies... */
166 if (gethash(&gcvm, cache->table,
167 (const void **)((void*)&cell)))
168 #else /* !GCCACHE_HASH */
170 /* start at the end (most recently used) */
173 if (gc_cache_eql(&gcvm, &cell->gcvm))
179 /* #### This whole file needs some serious overhauling. */
180 if (!(mask | GCTile) && cell->gc->values.tile)
182 else if (!(mask | GCStipple) && cell->gc->values.stipple)
184 #endif /* !GCCACHE_HASH */
187 /* Found a cell. Move this cell to the end of
188 the list, so that it will be less likely to
189 be collected than a cell that was accessed
197 if (cell == cache->tail)
205 if (cache->head == cell)
208 cell->prev = cache->tail;
210 cache->tail->next = cell;
214 if (cache->head == cell)
218 else if (cache->head != NULL && cache->head->prev)
220 else if (cache->tail != NULL && cache->tail->next)
226 /* else, cache miss. */
229 else if (cache->size == GC_CACHE_SIZE)
230 /* Reuse the first cell on the list
231 (least-recently-used). Remove it from the
232 list, and unhash it from the table.
236 cache->head = cell->next;
237 cache->head->prev = 0;
238 if (cache->tail == cell)
239 cache->tail = 0; /* only one */
240 XFreeGC(cache->dpy, cell->gc);
241 cache->delete_count++;
243 remhash(&cell->gcvm, cache->table);
245 } else if (cache->size > GC_CACHE_SIZE)
248 /* Allocate a new cell (don't put it in the
249 list or table yet). */
250 cell = xnew(struct gc_cache_cell);
254 /* Now we've got a cell (new or reused). Fill
256 memcpy(&cell->gcvm.gcv, gcv, sizeof(XGCValues));
257 cell->gcvm.mask = mask;
259 /* Put the cell on the end of the list. */
261 cell->prev = cache->tail;
263 cache->tail->next = cell;
267 cache->create_count++;
269 /* Hash it in the table */
270 puthash(&cell->gcvm, cell, cache->table);
272 /* Now make and return the GC. */
273 cell->gc = XCreateGC(cache->dpy, cache->window,
276 assert(cell->gc == gc_cache_lookup(cache, gcv, mask));
280 return NULL; /* No cell determined */
285 void describe_gc_cache(struct gc_cache *cache);
286 void describe_gc_cache(struct gc_cache *cache)
289 struct gc_cache_cell *cell = cache->head;
290 stderr_out("\nsize: %d", cache->size);
291 stderr_out("\ncreated: %d", cache->create_count);
292 stderr_out("\ndeleted: %d", cache->delete_count);
294 struct gc_cache_cell *cell2;
296 stderr_out("\n%d:\t0x%lx GC: 0x%08lx hash: 0x%08lx\n",
297 count, (long)cell, (long)cell->gc,
298 gc_cache_hash(&cell->gcvm));
299 for (cell2 = cache->head; cell2; cell2 = cell2->next, i++)
301 gc_cache_hash(&cell->gcvm) ==
302 gc_cache_hash(&cell2->gcvm))
303 stderr_out("\tHASH COLLISION with cell %d\n",
305 stderr_out("\tmask: %8lx\n", cell->gcvm.mask);
307 #define FROB(field) do { \
308 if ((int)cell->gcvm.gcv.field != (~0)) \
309 stderr_out ("\t%-12s%8x\n", #field ":", (int)cell->gcvm.gcv.field); \
327 FROB(subwindow_mode);
328 FROB(graphics_exposures);
336 if (cell->next && cell == cache->tail)
337 stderr_out("\nERROR! tail is here!\n\n");
338 else if (!cell->next && cell != cache->tail)
339 stderr_out("\nERROR! tail is not at the end\n\n");
342 if (count != cache->size)
343 stderr_out("\nERROR! count should be %d\n\n", cache->size);
346 #endif /* DEBUG_SXEMACS */