Mercurial > hg > xemacs-beta

comparison src/xgccache.c @ 0:376386a54a3c r19-14

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Import from CVS: tag r19-14
author cvs
date Mon, 13 Aug 2007 08:45:50 +0200
parents
children 3d6bfa290dbd
comparison
equal deleted inserted replaced
-1:000000000000 0:376386a54a3c
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 hashtables. 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 c_hashtable table;
88 #endif
89
90 int create_count;
91 int delete_count;
92 };
93
94 #ifdef GCCACHE_HASH
95 static unsigned long
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 unsigned long 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 < (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 =
125 (struct gc_cache *) xmalloc (sizeof (struct gc_cache));
126 cache->dpy = dpy;
127 cache->window = window;
128 cache->size = 0;
129 cache->head = cache->tail = 0;
130 cache->create_count = cache->delete_count = 0;
131 #ifdef GCCACHE_HASH
132 cache->table =
133 make_general_hashtable (GC_CACHE_SIZE, gc_cache_hash, gc_cache_eql);
134 #endif
135 return cache;
136 }
137
138 void
139 free_gc_cache (struct gc_cache *cache)
140 {
141 struct gc_cache_cell *rest, *next;
142 rest = cache->head;
143 while (rest)
144 {
145 XFreeGC (cache->dpy, rest->gc);
146 next = rest->next;
147 xfree (rest);
148 rest = next;
149 }
150 #ifdef GCCACHE_HASH
151 free_hashtable (cache->table);
152 #endif
153 xfree (cache);
154 }
155
156 GC
157 gc_cache_lookup (struct gc_cache *cache, XGCValues *gcv, unsigned long mask)
158 {
159 struct gc_cache_cell *cell, *next, *prev;
160 struct gcv_and_mask gcvm;
161
162 if ((!!cache->head) != (!!cache->tail)) abort ();
163 if (cache->head && (cache->head->prev || cache->tail->next)) abort ();
164
165 gcvm.mask = mask;
166 gcvm.gcv = *gcv; /* this copies... */
167
168 #ifdef GCCACHE_HASH
169
170 if (gethash (&gcvm, cache->table, (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 (cell == cache->tail)
199 return cell->gc;
200
201 next = cell->next;
202 prev = cell->prev;
203 if (prev) prev->next = next;
204 if (next) next->prev = prev;
205 if (cache->head == cell) cache->head = next;
206 cell->next = 0;
207 cell->prev = cache->tail;
208 cache->tail->next = cell;
209 cache->tail = cell;
210 if (cache->head == cell) abort ();
211 if (cell->next) abort ();
212 if (cache->head->prev) abort ();
213 if (cache->tail->next) abort ();
214 return cell->gc;
215 }
216
217 /* else, cache miss. */
218
219 if (cache->size == GC_CACHE_SIZE)
220 /* Reuse the first cell on the list (least-recently-used).
221 Remove it from the list, and unhash it from the table.
222 */
223 {
224 cell = cache->head;
225 cache->head = cell->next;
226 cache->head->prev = 0;
227 if (cache->tail == cell) cache->tail = 0; /* only one */
228 XFreeGC (cache->dpy, cell->gc);
229 cache->delete_count++;
230 #ifdef GCCACHE_HASH
231 remhash (&cell->gcvm, cache->table);
232 #endif
233 }
234 else if (cache->size > GC_CACHE_SIZE)
235 abort ();
236 else
237 {
238 /* Allocate a new cell (don't put it in the list or table yet).
239 */
240 cell = (struct gc_cache_cell *) xmalloc (sizeof (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 #if 1
272
273 #include <stdio.h>
274
275 void describe_gc_cache (struct gc_cache *cache);
276 void
277 describe_gc_cache (struct gc_cache *cache)
278 {
279 int count = 0;
280 struct gc_cache_cell *cell = cache->head;
281 stderr_out ("\nsize: %d", cache->size);
282 stderr_out ("\ncreated: %d", cache->create_count);
283 stderr_out ("\ndeleted: %d", cache->delete_count);
284 while (cell)
285 {
286 struct gc_cache_cell *cell2;
287 int i = 0;
288 stderr_out ("\n%d:\t0x%lx GC: 0x%08lx hash: 0x%08lx\n",
289 count, (long) cell, (long) cell->gc, gc_cache_hash (&cell->gcvm));
290 for (cell2 = cache->head; cell2; cell2 = cell2->next, i++)
291 if (count != i &&
292 gc_cache_hash (&cell->gcvm) == gc_cache_hash (&cell2->gcvm))
293 stderr_out ("\tHASH COLLISION with cell %d\n", i);
294 stderr_out ("\tmask: %8lx\n", cell->gcvm.mask);
295 #define F(x) (int)cell->gcvm.gcv.x
296 #define G(w,x) if (F(x) != (~0)) stderr_out ("\t%-12s%8x\n", w, F(x))
297 G("function:", function);
298 G("plane_mask:", plane_mask);
299 G("foreground:", foreground);
300 G("background:", background);
301 G("line_width:", line_width);
302 G("line_style:", line_style);
303 G("cap_style:", cap_style);
304 G("join_style:", join_style);
305 G("fill_style:", fill_style);
306 G("fill_rule:", fill_rule);
307 G("arc_mode:", arc_mode);
308 G("tile:", tile);
309 G("stipple:", stipple);
310 G("tsx_origin:", ts_x_origin);
311 G("tsy_origin:", ts_y_origin);
312 G("font:", font);
313 G("subwindow:", subwindow_mode);
314 G("gexposures:", graphics_exposures);
315 G("clip_x:", clip_x_origin);
316 G("clip_y:", clip_y_origin);
317 G("clip_mask:", clip_mask);
318 G("dash_off:", dash_offset);
319 #undef F
320 #undef G
321 count++;
322 if (cell->next && cell == cache->tail)
323 stderr_out ("\nERROR! tail is here!\n\n");
324 else if (!cell->next && cell != cache->tail)
325 stderr_out ("\nERROR! tail is not at the end\n\n");
326 cell = cell->next;
327 }
328 if (count != cache->size)
329 stderr_out ("\nERROR! count should be %d\n\n", cache->size);
330 }
331
332 #endif