Mercurial > hg > xemacs-beta
annotate src/gccache-x.c @ 5258:1ed4cefddd12
Add a couple of extra docstring backslashes, #'format-time-string
2010-09-05 Aidan Kehoe <kehoea@parhasard.net>
* editfns.c (Fformat_time_string):
Use two backslashes so that there is at least one present in the
output of describe function, when describing the Roman month
number syntax in this function's docstring. Thanks for provoking
me to look at this, Stephen Turnbull.
| author | Aidan Kehoe <kehoea@parhasard.net> |
|---|---|
| date | Sun, 05 Sep 2010 19:22:37 +0100 |
| parents | 6f2158fa75ed |
| children | 308d34e9f07d |
| rev | line source |
|---|---|
| 2587 | 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. | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
4 Copyright (C) 2010 Ben Wing. |
| 2587 | 5 |
| 6 This file is part of XEmacs. | |
| 7 | |
| 8 XEmacs is free software; you can redistribute it and/or modify it | |
| 9 under the terms of the GNU General Public License as published by the | |
| 10 Free Software Foundation; either version 2, or (at your option) any | |
| 11 later version. | |
| 12 | |
| 13 XEmacs is distributed in the hope that it will be useful, but WITHOUT | |
| 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with XEmacs; see the file COPYING. If not, write to | |
| 20 the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | |
| 21 Boston, MA 02111-1307, USA. */ | |
| 22 | |
| 23 /* Synched up with: Not in FSF. */ | |
| 24 | |
| 25 /* Emacs uses a lot of different display attributes; for example, assume | |
| 26 that only four fonts are in use (normal, bold, italic, and bold-italic). | |
| 27 Then assume that one stipple or background is used for text selections, | |
| 28 and another is used for highlighting mousable regions. That makes 16 | |
| 29 GCs already. Add in the fact that another GC may be needed to display | |
| 30 the text cursor in any of those regions, and you've got 32. Add in | |
| 31 more fonts, and it keeps increasing exponentially. | |
| 32 | |
| 33 We used to keep these GCs in a cache of merged (fully qualified) faces. | |
| 34 However, a lot of other code in xterm.c used XChangeGC of existing GCs, | |
| 35 which is kind of slow and kind of random. Also, managing the face cache | |
| 36 was tricky because it was hard to know when a face was no longer visible | |
| 37 on the frame -- we had to mark all frames as garbaged whenever a face | |
| 38 was changed, which caused an unpleasant amount of flicker (since faces are | |
| 39 created/destroyed (= changed) whenever a frame is created/destroyed. | |
| 40 | |
| 41 So this code maintains a cache at the GC level instead of at the face | |
| 42 level. There is an upper limit on the size of the cache, after which we | |
| 43 will stop creating GCs and start reusing them (reusing the least-recently- | |
| 44 used ones first). So if faces get changed, their GCs will eventually be | |
| 45 recycled. Also more sharing of GCs is possible. | |
| 46 | |
| 47 This code uses hash tables. It could be that, if the cache size is small | |
| 48 enough, a linear search might be faster; but I doubt it, since we need | |
| 49 `equal' comparisons, not `eq', and I expect that the optimal cache size | |
| 50 will be ~100. | |
| 51 | |
| 52 Written by jwz, 14 jun 93 | |
| 53 */ | |
| 54 | |
| 55 #include <config.h> | |
|
4908
b3ce27ca7647
various fixes related to gtk, redisplay-xlike-inc.c
Ben Wing <ben@xemacs.org>
parents:
3243
diff
changeset
|
56 #include "lisp.h" |
|
b3ce27ca7647
various fixes related to gtk, redisplay-xlike-inc.c
Ben Wing <ben@xemacs.org>
parents:
3243
diff
changeset
|
57 #include "hash.h" |
|
b3ce27ca7647
various fixes related to gtk, redisplay-xlike-inc.c
Ben Wing <ben@xemacs.org>
parents:
3243
diff
changeset
|
58 |
| 4917 | 59 #include "gccache-x.h" |
| 2587 | 60 |
| 61 #define GC_CACHE_SIZE 100 | |
| 62 | |
| 63 #define GCCACHE_HASH | |
| 64 | |
| 65 struct gcv_and_mask { | |
| 66 XGCValues gcv; | |
| 67 unsigned long mask; | |
| 68 }; | |
| 69 | |
| 70 struct gc_cache_cell { | |
| 71 GC gc; | |
| 72 struct gcv_and_mask gcvm; | |
| 73 struct gc_cache_cell *prev, *next; | |
| 74 }; | |
| 75 | |
| 76 struct gc_cache { | |
| 77 Display *dpy; /* used only as arg to XCreateGC/XFreeGC */ | |
| 78 Window window; /* used only as arg to XCreateGC */ | |
| 79 int size; | |
| 80 struct gc_cache_cell *head; | |
| 81 struct gc_cache_cell *tail; | |
| 82 #ifdef GCCACHE_HASH | |
| 83 struct hash_table *table; | |
| 84 #endif | |
| 85 | |
| 86 int create_count; | |
| 87 int delete_count; | |
| 88 }; | |
| 89 | |
| 90 #ifdef GCCACHE_HASH | |
| 91 static Hashcode | |
| 92 gc_cache_hash (const void *arg) | |
| 93 { | |
| 94 const struct gcv_and_mask *gcvm = (const struct gcv_and_mask *) arg; | |
| 95 unsigned long *longs = (unsigned long *) &gcvm->gcv; | |
| 96 Hashcode hash = gcvm->mask; | |
| 97 int i; | |
| 98 /* This could look at the mask and only use the used slots in the | |
| 99 hash code. That would win in that we wouldn't have to initialize | |
| 100 every slot of the gcv when calling gc_cache_lookup. But we need | |
| 101 the hash function to be as fast as possible; some timings should | |
| 102 be done. */ | |
| 103 for (i = 0; i < (int) (sizeof (XGCValues) / sizeof (unsigned long)); i++) | |
| 104 hash = (hash << 1) ^ *longs++; | |
| 105 return hash; | |
| 106 } | |
| 107 | |
| 108 #endif /* GCCACHE_HASH */ | |
| 109 | |
| 110 static int | |
| 111 gc_cache_eql (const void *arg1, const void *arg2) | |
| 112 { | |
| 113 /* See comment in gc_cache_hash */ | |
| 114 return !memcmp (arg1, arg2, sizeof (struct gcv_and_mask)); | |
| 115 } | |
| 116 | |
| 117 struct gc_cache * | |
| 118 make_gc_cache (Display *dpy, Window window) | |
| 119 { | |
| 120 struct gc_cache *cache = xnew (struct gc_cache); | |
| 121 cache->dpy = dpy; | |
| 122 cache->window = window; | |
| 123 cache->size = 0; | |
| 124 cache->head = cache->tail = 0; | |
| 125 cache->create_count = cache->delete_count = 0; | |
| 126 #ifdef GCCACHE_HASH | |
| 127 cache->table = | |
| 128 make_general_hash_table (GC_CACHE_SIZE, gc_cache_hash, gc_cache_eql); | |
| 129 #endif | |
| 130 return cache; | |
| 131 } | |
| 132 | |
| 133 void | |
| 134 free_gc_cache (struct gc_cache *cache) | |
| 135 { | |
| 136 struct gc_cache_cell *rest, *next; | |
| 137 rest = cache->head; | |
| 138 while (rest) | |
| 139 { | |
| 140 XFreeGC (cache->dpy, rest->gc); | |
| 141 next = rest->next; | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4917
diff
changeset
|
142 xfree (rest); |
| 2587 | 143 rest = next; |
| 144 } | |
| 145 #ifdef GCCACHE_HASH | |
| 146 free_hash_table (cache->table); | |
| 147 #endif | |
|
4976
16112448d484
Rename xfree(FOO, TYPE) -> xfree(FOO)
Ben Wing <ben@xemacs.org>
parents:
4917
diff
changeset
|
148 xfree (cache); |
| 2587 | 149 } |
| 150 | |
| 151 GC | |
| 152 gc_cache_lookup (struct gc_cache *cache, XGCValues *gcv, unsigned long mask) | |
| 153 { | |
| 154 struct gc_cache_cell *cell, *next, *prev; | |
| 155 struct gcv_and_mask gcvm; | |
| 156 | |
| 3094 | 157 #ifdef DEBUG_XEMACS |
| 158 (void) describe_gc_cache (cache, DGCCFLAG_DISABLE); | |
| 159 #endif | |
| 160 | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
161 assert ((!!cache->head) == (!!cache->tail)); |
|
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
162 assert (!(cache->head && (cache->head->prev || cache->tail->next))); |
| 2587 | 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 */ | |
| 3094 | 199 #if 0 |
| 200 debug_out ("Returning cached GC: %08lx\n", XE_GCONTEXT(cell)); | |
| 201 #endif | |
| 2587 | 202 if (cell == cache->tail) |
| 203 return cell->gc; | |
| 204 | |
| 205 next = cell->next; | |
| 206 prev = cell->prev; | |
| 207 if (prev) prev->next = next; | |
| 208 if (next) next->prev = prev; | |
| 209 if (cache->head == cell) cache->head = next; | |
| 210 cell->next = 0; | |
| 211 cell->prev = cache->tail; | |
| 212 cache->tail->next = cell; | |
| 213 cache->tail = cell; | |
|
5050
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
214 assert (cache->head != cell); |
|
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
215 assert (!cell->next); |
|
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
216 assert (!cache->head->prev); |
|
6f2158fa75ed
Fix quick-build, use asserts() in place of ABORT()
Ben Wing <ben@xemacs.org>
parents:
4976
diff
changeset
|
217 assert (!cache->tail->next); |
| 2587 | 218 return cell->gc; |
| 219 } | |
| 220 | |
| 221 /* else, cache miss. */ | |
| 222 | |
| 223 if (cache->size == GC_CACHE_SIZE) | |
| 224 /* Reuse the first cell on the list (least-recently-used). | |
| 225 Remove it from the list, and unhash it from the table. | |
| 226 */ | |
| 227 { | |
| 228 cell = cache->head; | |
| 229 cache->head = cell->next; | |
| 230 cache->head->prev = 0; | |
| 231 if (cache->tail == cell) cache->tail = 0; /* only one */ | |
| 3243 | 232 #if 0 |
| 3094 | 233 debug_out ("Cache full, freeing GC: %08lx\n ", XE_GCONTEXT(cell)); |
| 3243 | 234 #endif |
| 2587 | 235 XFreeGC (cache->dpy, cell->gc); |
| 236 cache->delete_count++; | |
| 237 #ifdef GCCACHE_HASH | |
| 238 remhash (&cell->gcvm, cache->table); | |
| 239 #endif | |
| 240 } | |
| 241 else if (cache->size > GC_CACHE_SIZE) | |
| 242 ABORT (); | |
| 243 else | |
| 244 { | |
| 245 /* Allocate a new cell (don't put it in the list or table yet). */ | |
| 246 cell = xnew (struct gc_cache_cell); | |
| 247 cache->size++; | |
| 248 } | |
| 249 | |
| 250 /* Now we've got a cell (new or reused). Fill it in. */ | |
| 251 memcpy (&cell->gcvm.gcv, gcv, sizeof (XGCValues)); | |
| 252 cell->gcvm.mask = mask; | |
| 253 | |
| 254 /* Put the cell on the end of the list. */ | |
| 255 cell->next = 0; | |
| 256 cell->prev = cache->tail; | |
| 257 if (cache->tail) cache->tail->next = cell; | |
| 258 cache->tail = cell; | |
| 259 if (! cache->head) cache->head = cell; | |
| 260 | |
| 261 cache->create_count++; | |
| 262 #ifdef GCCACHE_HASH | |
| 263 /* Hash it in the table */ | |
| 264 puthash (&cell->gcvm, cell, cache->table); | |
| 265 #endif | |
| 266 | |
| 267 /* Now make and return the GC. */ | |
| 268 cell->gc = XCreateGC (cache->dpy, cache->window, mask, gcv); | |
| 269 | |
| 270 /* debug */ | |
| 271 assert (cell->gc == gc_cache_lookup (cache, gcv, mask)); | |
| 272 | |
| 3094 | 273 #if 0 |
| 274 debug_out ("Returning new GC: %08lx\n ", XE_GCONTEXT(cell)); | |
| 275 #endif | |
| 2587 | 276 return cell->gc; |
| 277 } | |
| 278 | |
| 279 | |
| 280 #ifdef DEBUG_XEMACS | |
| 281 | |
| 3094 | 282 /* FLAGS |
| 283 The flags argument is a bitwise or of any of the following: | |
| 284 | |
| 285 DGCCFLAG_SUMMARY Summary statistics for cache | |
| 286 DGCCFLAG_LIST_CELLS If summary is being printed, print cell IDs too. | |
| 287 DGCCFLAG_CELL_DETAILS If cell IDs are being printed, additionally | |
| 288 print the internal fields used and values. | |
| 289 | |
| 290 DGCCFLAG_DEFAULT A predefined combination giving whatever the | |
| 291 maintainers are currently interested in seeing. | |
| 292 */ | |
| 2587 | 293 void |
| 3094 | 294 describe_gc_cache (struct gc_cache *cache, int flags) |
| 2587 | 295 { |
| 296 int count = 0; | |
| 297 struct gc_cache_cell *cell = cache->head; | |
| 3094 | 298 |
| 299 if (! flags & DGCCFLAG_SUMMARY) return; | |
| 300 | |
| 2587 | 301 stderr_out ("\nsize: %d", cache->size); |
| 302 stderr_out ("\ncreated: %d", cache->create_count); | |
| 303 stderr_out ("\ndeleted: %d", cache->delete_count); | |
| 304 | |
| 3094 | 305 if (flags & DGCCFLAG_LIST_CELLS) |
| 306 while (cell) | |
| 307 { | |
| 308 struct gc_cache_cell *cell2; | |
| 309 int i = 0; | |
| 310 stderr_out ("\n%d:\t0x%lx GC: 0x%08lx hash: 0x%08lx\n", | |
| 311 count, (long) cell, (long) XE_GCONTEXT(cell), | |
| 312 gc_cache_hash (&cell->gcvm)); | |
| 313 | |
| 314 for (cell2 = cache->head; cell2; cell2 = cell2->next, i++) | |
| 315 if (count != i && | |
| 316 gc_cache_hash (&cell->gcvm) == gc_cache_hash (&cell2->gcvm)) | |
| 317 stderr_out ("\tHASH COLLISION with cell %d\n", i); | |
| 318 stderr_out ("\tmask: %8lx\n", cell->gcvm.mask); | |
| 319 | |
| 320 if (flags & DGCCFLAG_CELL_DETAILS) | |
| 321 { | |
| 2587 | 322 #define FROB(field) do { \ |
| 323 if ((int)cell->gcvm.gcv.field != (~0)) \ | |
| 324 stderr_out ("\t%-12s%8x\n", #field ":", (int)cell->gcvm.gcv.field); \ | |
| 325 } while (0) | |
| 3094 | 326 FROB (function); |
| 327 FROB (plane_mask); | |
| 328 FROB (foreground); | |
| 329 FROB (background); | |
| 330 FROB (line_width); | |
| 331 FROB (line_style); | |
| 332 FROB (cap_style); | |
| 333 FROB (join_style); | |
| 334 FROB (fill_style); | |
| 335 FROB (fill_rule); | |
| 336 FROB (arc_mode); | |
| 337 FROB (tile); | |
| 338 FROB (stipple); | |
| 339 FROB (ts_x_origin); | |
| 340 FROB (ts_y_origin); | |
| 341 FROB (font); | |
| 342 FROB (subwindow_mode); | |
| 343 FROB (graphics_exposures); | |
| 344 FROB (clip_x_origin); | |
| 345 FROB (clip_y_origin); | |
| 346 FROB (clip_mask); | |
| 347 FROB (dash_offset); | |
| 2587 | 348 #undef FROB |
| 3094 | 349 } |
| 2587 | 350 |
| 3094 | 351 count++; |
| 352 if (cell->next && cell == cache->tail) | |
| 353 stderr_out ("\nERROR! tail is here!\n\n"); | |
| 354 else if (!cell->next && cell != cache->tail) | |
| 355 stderr_out ("\nERROR! tail is not at the end\n\n"); | |
| 356 cell = cell->next; | |
| 357 } /* while (cell) */ | |
| 358 | |
| 2587 | 359 if (count != cache->size) |
| 360 stderr_out ("\nERROR! count should be %d\n\n", cache->size); | |
| 361 } | |
| 362 | |
| 363 #endif /* DEBUG_XEMACS */ |