Mercurial > hg > xemacs-beta

comparison src/gccache-x.c @ 5125:b5df3737028a ben-lisp-object

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
merge
author Ben Wing <ben@xemacs.org>
date Wed, 24 Feb 2010 01:58:04 -0600
parents 16112448d484
children 6f2158fa75ed
comparison
equal deleted inserted replaced
5124:623d57b7fbe8 5125:b5df3737028a
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 "lisp.h"
56 #include "hash.h"
57
58 #include "gccache-x.h"
59
60 #define GC_CACHE_SIZE 100
61
62 #define GCCACHE_HASH
63
64 struct gcv_and_mask {
65 XGCValues gcv;
66 unsigned long mask;
67 };
68
69 struct gc_cache_cell {
70 GC gc;
71 struct gcv_and_mask gcvm;
72 struct gc_cache_cell *prev, *next;
73 };
74
75 struct gc_cache {
76 Display *dpy; /* used only as arg to XCreateGC/XFreeGC */
77 Window window; /* used only as arg to XCreateGC */
78 int size;
79 struct gc_cache_cell *head;
80 struct gc_cache_cell *tail;
81 #ifdef GCCACHE_HASH
82 struct hash_table *table;
83 #endif
84
85 int create_count;
86 int delete_count;
87 };
88
89 #ifdef GCCACHE_HASH
90 static Hashcode
91 gc_cache_hash (const void *arg)
92 {
93 const struct gcv_and_mask *gcvm = (const struct gcv_and_mask *) arg;
94 unsigned long *longs = (unsigned long *) &gcvm->gcv;
95 Hashcode hash = gcvm->mask;
96 int i;
97 /* This could look at the mask and only use the used slots in the
98 hash code. That would win in that we wouldn't have to initialize
99 every slot of the gcv when calling gc_cache_lookup. But we need
100 the hash function to be as fast as possible; some timings should
101 be done. */
102 for (i = 0; i < (int) (sizeof (XGCValues) / sizeof (unsigned long)); i++)
103 hash = (hash << 1) ^ *longs++;
104 return hash;
105 }
106
107 #endif /* GCCACHE_HASH */
108
109 static int
110 gc_cache_eql (const void *arg1, const void *arg2)
111 {
112 /* See comment in gc_cache_hash */
113 return !memcmp (arg1, arg2, sizeof (struct gcv_and_mask));
114 }
115
116 struct gc_cache *
117 make_gc_cache (Display *dpy, Window window)
118 {
119 struct gc_cache *cache = xnew (struct gc_cache);
120 cache->dpy = dpy;
121 cache->window = window;
122 cache->size = 0;
123 cache->head = cache->tail = 0;
124 cache->create_count = cache->delete_count = 0;
125 #ifdef GCCACHE_HASH
126 cache->table =
127 make_general_hash_table (GC_CACHE_SIZE, gc_cache_hash, gc_cache_eql);
128 #endif
129 return cache;
130 }
131
132 void
133 free_gc_cache (struct gc_cache *cache)
134 {
135 struct gc_cache_cell *rest, *next;
136 rest = cache->head;
137 while (rest)
138 {
139 XFreeGC (cache->dpy, rest->gc);
140 next = rest->next;
141 xfree (rest);
142 rest = next;
143 }
144 #ifdef GCCACHE_HASH
145 free_hash_table (cache->table);
146 #endif
147 xfree (cache);
148 }
149
150 GC
151 gc_cache_lookup (struct gc_cache *cache, XGCValues *gcv, unsigned long mask)
152 {
153 struct gc_cache_cell *cell, *next, *prev;
154 struct gcv_and_mask gcvm;
155
156 #ifdef DEBUG_XEMACS
157 (void) describe_gc_cache (cache, DGCCFLAG_DISABLE);
158 #endif
159
160 if ((!!cache->head) != (!!cache->tail)) ABORT ();
161 if (cache->head && (cache->head->prev || cache->tail->next)) ABORT ();
162
163 gcvm.mask = mask;
164 gcvm.gcv = *gcv; /* this copies... */
165
166 #ifdef GCCACHE_HASH
167
168 /* The intermediate cast fools gcc into not outputting strict-aliasing
169 complaints */
170 if (gethash (&gcvm, cache->table, (const void **) (void *) &cell))
171
172 #else /* !GCCACHE_HASH */
173
174 cell = cache->tail; /* start at the end (most recently used) */
175 while (cell)
176 {
177 if (gc_cache_eql (&gcvm, &cell->gcvm))
178 break;
179 else
180 cell = cell->prev;
181 }
182
183 /* #### This whole file needs some serious overhauling. */
184 if (!(mask | GCTile) && cell->gc->values.tile)
185 cell = 0;
186 else if (!(mask | GCStipple) && cell->gc->values.stipple)
187 cell = 0;
188
189 if (cell)
190
191 #endif /* !GCCACHE_HASH */
192
193 {
194 /* Found a cell. Move this cell to the end of the list, so that it
195 will be less likely to be collected than a cell that was accessed
196 less recently.
197 */
198 #if 0
199 debug_out ("Returning cached GC: %08lx\n", XE_GCONTEXT(cell));
200 #endif
201 if (cell == cache->tail)
202 return cell->gc;
203
204 next = cell->next;
205 prev = cell->prev;
206 if (prev) prev->next = next;
207 if (next) next->prev = prev;
208 if (cache->head == cell) cache->head = next;
209 cell->next = 0;
210 cell->prev = cache->tail;
211 cache->tail->next = cell;
212 cache->tail = cell;
213 if (cache->head == cell) ABORT ();
214 if (cell->next) ABORT ();
215 if (cache->head->prev) ABORT ();
216 if (cache->tail->next) ABORT ();
217 return cell->gc;
218 }
219
220 /* else, cache miss. */
221
222 if (cache->size == GC_CACHE_SIZE)
223 /* Reuse the first cell on the list (least-recently-used).
224 Remove it from the list, and unhash it from the table.
225 */
226 {
227 cell = cache->head;
228 cache->head = cell->next;
229 cache->head->prev = 0;
230 if (cache->tail == cell) cache->tail = 0; /* only one */
231 #if 0
232 debug_out ("Cache full, freeing GC: %08lx\n ", XE_GCONTEXT(cell));
233 #endif
234 XFreeGC (cache->dpy, cell->gc);
235 cache->delete_count++;
236 #ifdef GCCACHE_HASH
237 remhash (&cell->gcvm, cache->table);
238 #endif
239 }
240 else if (cache->size > GC_CACHE_SIZE)
241 ABORT ();
242 else
243 {
244 /* Allocate a new cell (don't put it in the list or table yet). */
245 cell = xnew (struct gc_cache_cell);
246 cache->size++;
247 }
248
249 /* Now we've got a cell (new or reused). Fill it in. */
250 memcpy (&cell->gcvm.gcv, gcv, sizeof (XGCValues));
251 cell->gcvm.mask = mask;
252
253 /* Put the cell on the end of the list. */
254 cell->next = 0;
255 cell->prev = cache->tail;
256 if (cache->tail) cache->tail->next = cell;
257 cache->tail = cell;
258 if (! cache->head) cache->head = cell;
259
260 cache->create_count++;
261 #ifdef GCCACHE_HASH
262 /* Hash it in the table */
263 puthash (&cell->gcvm, cell, cache->table);
264 #endif
265
266 /* Now make and return the GC. */
267 cell->gc = XCreateGC (cache->dpy, cache->window, mask, gcv);
268
269 /* debug */
270 assert (cell->gc == gc_cache_lookup (cache, gcv, mask));
271
272 #if 0
273 debug_out ("Returning new GC: %08lx\n ", XE_GCONTEXT(cell));
274 #endif
275 return cell->gc;
276 }
277
278
279 #ifdef DEBUG_XEMACS
280
281 /* FLAGS
282 The flags argument is a bitwise or of any of the following:
283
284 DGCCFLAG_SUMMARY Summary statistics for cache
285 DGCCFLAG_LIST_CELLS If summary is being printed, print cell IDs too.
286 DGCCFLAG_CELL_DETAILS If cell IDs are being printed, additionally
287 print the internal fields used and values.
288
289 DGCCFLAG_DEFAULT A predefined combination giving whatever the
290 maintainers are currently interested in seeing.
291 */
292 void
293 describe_gc_cache (struct gc_cache *cache, int flags)
294 {
295 int count = 0;
296 struct gc_cache_cell *cell = cache->head;
297
298 if (! flags & DGCCFLAG_SUMMARY) return;
299
300 stderr_out ("\nsize: %d", cache->size);
301 stderr_out ("\ncreated: %d", cache->create_count);
302 stderr_out ("\ndeleted: %d", cache->delete_count);
303
304 if (flags & DGCCFLAG_LIST_CELLS)
305 while (cell)
306 {
307 struct gc_cache_cell *cell2;
308 int i = 0;
309 stderr_out ("\n%d:\t0x%lx GC: 0x%08lx hash: 0x%08lx\n",
310 count, (long) cell, (long) XE_GCONTEXT(cell),
311 gc_cache_hash (&cell->gcvm));
312
313 for (cell2 = cache->head; cell2; cell2 = cell2->next, i++)
314 if (count != i &&
315 gc_cache_hash (&cell->gcvm) == gc_cache_hash (&cell2->gcvm))
316 stderr_out ("\tHASH COLLISION with cell %d\n", i);
317 stderr_out ("\tmask: %8lx\n", cell->gcvm.mask);
318
319 if (flags & DGCCFLAG_CELL_DETAILS)
320 {
321 #define FROB(field) do { \
322 if ((int)cell->gcvm.gcv.field != (~0)) \
323 stderr_out ("\t%-12s%8x\n", #field ":", (int)cell->gcvm.gcv.field); \
324 } while (0)
325 FROB (function);
326 FROB (plane_mask);
327 FROB (foreground);
328 FROB (background);
329 FROB (line_width);
330 FROB (line_style);
331 FROB (cap_style);
332 FROB (join_style);
333 FROB (fill_style);
334 FROB (fill_rule);
335 FROB (arc_mode);
336 FROB (tile);
337 FROB (stipple);
338 FROB (ts_x_origin);
339 FROB (ts_y_origin);
340 FROB (font);
341 FROB (subwindow_mode);
342 FROB (graphics_exposures);
343 FROB (clip_x_origin);
344 FROB (clip_y_origin);
345 FROB (clip_mask);
346 FROB (dash_offset);
347 #undef FROB
348 }
349
350 count++;
351 if (cell->next && cell == cache->tail)
352 stderr_out ("\nERROR! tail is here!\n\n");
353 else if (!cell->next && cell != cache->tail)
354 stderr_out ("\nERROR! tail is not at the end\n\n");
355 cell = cell->next;
356 } /* while (cell) */
357
358 if (count != cache->size)
359 stderr_out ("\nERROR! count should be %d\n\n", cache->size);
360 }
361
362 #endif /* DEBUG_XEMACS */