Mercurial > hg > xemacs-beta

comparison src/lrecord.h @ 5170:5ddbab03b0e6

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
various fixes to memory-usage stats -------------------- ChangeLog entries follow: -------------------- lisp/ChangeLog addition: 2010-03-25 Ben Wing <ben@xemacs.org> * diagnose.el (show-memory-usage): * diagnose.el (show-object-memory-usage-stats): Further changes to correspond with changes in the C code; add an additional column in show-object-memory-usage-stats showing the ancillary Lisp overhead used with each type; shrink columns for windows in show-memory-usage to get it to fit in 79 chars. src/ChangeLog addition: 2010-03-25 Ben Wing <ben@xemacs.org> * alloc.c: * alloc.c (struct): * alloc.c (finish_object_memory_usage_stats): * alloc.c (object_memory_usage_stats): * alloc.c (Fobject_memory_usage): * alloc.c (lisp_object_memory_usage_full): * alloc.c (compute_memusage_stats_length): * lrecord.h: * lrecord.h (struct lrecord_implementation): Add fields to the `lrecord_implementation' structure to list an offset into the array of extra statistics in a `struct generic_usage_stats' and a length, listing the first slice of ancillary Lisp-object memory. Compute automatically in compute_memusage_stats_length(). Use to add an entry `FOO-lisp-ancillary-storage' for object type FOO. Don't crash when an int or char is given to object-memory-usage, signal an error instead. Add functions lisp_object_memory_usage_full() and lisp_object_memory_usage() to compute the total memory usage of an object (sum of object, non-Lisp attached, and Lisp ancillary memory). * array.c: * array.c (gap_array_memory_usage): * array.h: Add function to return memory usage of a gap array. * buffer.c (struct buffer_stats): * buffer.c (compute_buffer_usage): * buffer.c (vars_of_buffer): * extents.c (compute_buffer_extent_usage): * marker.c: * marker.c (compute_buffer_marker_usage): * extents.h: * lisp.h: Remove `struct usage_stats' arg from compute_buffer_marker_usage() and compute_buffer_extent_usage() -- these are ancillary Lisp objects and don't get accumulated into `struct usage_stats'; change the value of `memusage_stats_list' so that `markers' and `extents' memory is in Lisp-ancillary, where it belongs. In compute_buffer_marker_usage(), use lisp_object_memory_usage() rather than lisp_object_storage_size(). * casetab.c: * casetab.c (case_table_memory_usage): * casetab.c (vars_of_casetab): * emacs.c (main_1): Add memory usage stats for case tables. * lisp.h: Add comment explaining the `struct generic_usage_stats' more, as well as the new fields in lrecord_implementation. * console-impl.h: * console-impl.h (struct console_methods): * scrollbar-gtk.c: * scrollbar-gtk.c (gtk_compute_scrollbar_instance_usage): * scrollbar-msw.c: * scrollbar-msw.c (mswindows_compute_scrollbar_instance_usage): * scrollbar-x.c: * scrollbar-x.c (x_compute_scrollbar_instance_usage): * scrollbar.c: * scrollbar.c (struct scrollbar_instance_stats): * scrollbar.c (compute_all_scrollbar_instance_usage): * scrollbar.c (scrollbar_instance_memory_usage): * scrollbar.c (scrollbar_objects_create): * scrollbar.c (vars_of_scrollbar): * scrollbar.h: * symsinit.h: * window.c: * window.c (find_window_mirror_maybe): * window.c (struct window_mirror_stats): * window.c (compute_window_mirror_usage): * window.c (window_mirror_memory_usage): * window.c (compute_window_usage): * window.c (window_objects_create): * window.c (syms_of_window): * window.c (vars_of_window): Redo memory-usage associated with windows, window mirrors, and scrollbar instances. Should fix crash in find_window_mirror, among other things. Properly assign memo ry to object memory, non-Lisp extra memory, and Lisp ancillary memory. For example, redisplay structures are non-Lisp memory hanging off a window mirror, not a window; make it an ancillary Lisp-object field. Window mirrors and scrollbar instances have their own statistics, among other things.
author Ben Wing <ben@xemacs.org>
date Thu, 25 Mar 2010 06:07:25 -0500
parents 6c6d78781d59
children 97eb4942aec8 14fda1dbdb26
comparison
equal deleted inserted replaced
5169:6c6d78781d59 5170:5ddbab03b0e6
512 unsigned int frob_block_p :1; 512 unsigned int frob_block_p :1;
513 #endif /* not NEW_GC */ 513 #endif /* not NEW_GC */
514 514
515 /**********************************************************************/ 515 /**********************************************************************/
516 /* Remaining stuff is not assignable statically using 516 /* Remaining stuff is not assignable statically using
517 DEFINE_*_LISP_OBJECT, but must be assigned with OBJECT_HAS_METHOD 517 DEFINE_*_LISP_OBJECT, but must be assigned with OBJECT_HAS_METHOD,
518 or the like. */ 518 OBJECT_HAS_PROPERTY or the like. */
519 519
520 /* These functions allow any object type to have builtin property 520 /* These functions allow any object type to have builtin property
521 lists that can be manipulated from the lisp level with 521 lists that can be manipulated from the lisp level with
522 `get', `put', `remprop', and `object-plist'. */ 522 `get', `put', `remprop', and `object-plist'. */
523 Lisp_Object (*getprop) (Lisp_Object obj, Lisp_Object prop); 523 Lisp_Object (*getprop) (Lisp_Object obj, Lisp_Object prop);
540 be NULL. */ 540 be NULL. */
541 void (*disksave) (Lisp_Object); 541 void (*disksave) (Lisp_Object);
542 542
543 #ifdef MEMORY_USAGE_STATS 543 #ifdef MEMORY_USAGE_STATS
544 /* Return memory-usage information about the object in question, stored 544 /* Return memory-usage information about the object in question, stored
545 into STATS. */ 545 into STATS.
546
547 Two types of information are stored: storage (including overhead) for
548 ancillary non-Lisp structures attached to the object, and storage
549 (including overhead) for ancillary Lisp objects attached to the
550 object. The third type of memory-usage information (storage for the
551 object itself) is not noted here, because it's computed automatically
552 by the calling function. Also, the computed storage for ancillary
553 Lisp objects is the sum of all three source of memory associated with
554 the Lisp object: the object itself, ancillary non-Lisp structures and
555 ancillary Lisp objects. Note also that the `struct usage_stats u' at
556 the beginning of the STATS structure is for ancillary non-Lisp usage
557 *ONLY*; do not store any memory into it related to ancillary Lisp
558 objects.
559
560 Note that it may be subjective which Lisp objects are considered
561 "attached" to the object. Some guidelines:
562
563 -- Lisp objects which are "internal" to the main object and not
564 accessible except through the main object should be included
565 -- Objects linked by a weak reference should *NOT* be included
566 */
546 void (*memory_usage) (Lisp_Object obj, struct generic_usage_stats *stats); 567 void (*memory_usage) (Lisp_Object obj, struct generic_usage_stats *stats);
547
548 /* Number of additional type-specific statistics related to memory usage.
549 Automatically calculated (see compute_memusage_stats_length()) based
550 on the value placed in `memusage_stats_list'. */
551 Elemcount num_extra_memusage_stats;
552
553 /* Number of additional type-specific statistics related to
554 non-Lisp-Object memory usage for this object. Automatically
555 calculated (see compute_memusage_stats_length()) based on the value
556 placed in `memusage_stats_list'. */
557 Elemcount num_extra_nonlisp_memusage_stats;
558 568
559 /* List of tags to be given to the extra statistics, one per statistic. 569 /* List of tags to be given to the extra statistics, one per statistic.
560 Qnil or Qt can be present to separate off different slices. Qnil 570 Qnil or Qt can be present to separate off different slices. Qnil
561 separates different slices within the same type of statistics. 571 separates different slices within the same group of statistics.
562 Qt separates slices corresponding to different types of statistics. 572 These represent different ways of partitioning the same memory space.
573 Qt separates different groups; these represent different spaces of
574 memory.
575
563 If Qt is not present, all slices describe extra non-Lisp-Object memory 576 If Qt is not present, all slices describe extra non-Lisp-Object memory
564 associated with a Lisp object. If Qt is present, slices after Qt 577 associated with a Lisp object. If Qt is present, slices before Qt
565 describe non-Lisp-Object memory and slices before Qt describe 578 describe non-Lisp-Object memory, as before, and slices after Qt
566 Lisp-Object memory logically associated with the object. For example, 579 describe ancillary Lisp-Object memory logically associated with the
567 if the object is a table, then Lisp-Object memory might be the entries 580 object. For example, if the object is a table, then ancillary
568 in the table. This info is only advisory since it will duplicate 581 Lisp-Object memory might be the entries in the table. This info is
569 memory described elsewhere and since it may not be possible to be 582 only advisory since it will duplicate memory described elsewhere and
570 completely accurate if the same object occurs multiple times in the 583 since it may not be possible to be completely accurate, e.g. it may
571 table. */ 584 not be clear what to count in "ancillary objects", and the value may
585 be too high if the same object occurs multiple times in the table. */
572 Lisp_Object memusage_stats_list; 586 Lisp_Object memusage_stats_list;
587
588 /* --------------------------------------------------------------------- */
589
590 /* The following are automatically computed based on the value in
591 `memusage_stats_list' (see compute_memusage_stats_length()). */
592
593 /* Total number of additional type-specific statistics related to memory
594 usage. */
595 Elemcount num_extra_memusage_stats;
596
597 /* Number of additional type-specific statistics belonging to the first
598 slice of the group describing non-Lisp-Object memory usage for this
599 object. These stats occur starting at offset 0. */
600 Elemcount num_extra_nonlisp_memusage_stats;
601
602 /* The offset into the extra statistics at which the Lisp-Object
603 memory-usage statistics begin. */
604 Elemcount offset_lisp_ancillary_memusage_stats;
605
606 /* Number of additional type-specific statistics belonging to the first
607 slice of the group describing Lisp-Object memory usage for this
608 object. These stats occur starting at offset
609 `offset_lisp_ancillary_memusage_stats'. */
610 Elemcount num_extra_lisp_ancillary_memusage_stats;
611
573 #endif /* MEMORY_USAGE_STATS */ 612 #endif /* MEMORY_USAGE_STATS */
574 }; 613 };
575 614
576 /* All the built-in lisp object types are enumerated in `enum lrecord_type'. 615 /* All the built-in lisp object types are enumerated in `enum lrecord_type'.
577 Additional ones may be defined by a module (none yet). We leave some 616 Additional ones may be defined by a module (none yet). We leave some
2038 MODULE_API void copy_lisp_object (Lisp_Object dst, Lisp_Object src); 2077 MODULE_API void copy_lisp_object (Lisp_Object dst, Lisp_Object src);
2039 MODULE_API void zero_sized_lisp_object (Lisp_Object obj, Bytecount size); 2078 MODULE_API void zero_sized_lisp_object (Lisp_Object obj, Bytecount size);
2040 MODULE_API void zero_nonsized_lisp_object (Lisp_Object obj); 2079 MODULE_API void zero_nonsized_lisp_object (Lisp_Object obj);
2041 Bytecount lisp_object_storage_size (Lisp_Object obj, 2080 Bytecount lisp_object_storage_size (Lisp_Object obj,
2042 struct usage_stats *ustats); 2081 struct usage_stats *ustats);
2082 Bytecount lisp_object_memory_usage_full (Lisp_Object object,
2083 Bytecount *storage_size,
2084 Bytecount *extra_nonlisp_storage,
2085 Bytecount *extra_lisp_storage,
2086 struct generic_usage_stats *stats);
2087 Bytecount lisp_object_memory_usage (Lisp_Object object);
2043 void free_normal_lisp_object (Lisp_Object obj); 2088 void free_normal_lisp_object (Lisp_Object obj);
2044 2089
2045 2090
2046 /************************************************************************/ 2091 /************************************************************************/
2047 /* Dumping */ 2092 /* Dumping */