redo memory-usage mechanism, add way of dynamically initializing Lisp objects -------------------- ChangeLog entries follow: -------------------- lisp/ChangeLog addition: 2010-03-18 Ben Wing <ben@xemacs.org> * diagnose.el (show-memory-usage): Rewrite to take into account API changes in memory-usage functions. src/ChangeLog addition: 2010-03-18 Ben Wing <ben@xemacs.org> * alloc.c: * alloc.c (disksave_object_finalization_1): * alloc.c (lisp_object_storage_size): * alloc.c (listu): * alloc.c (listn): * alloc.c (Fobject_memory_usage_stats): * alloc.c (compute_memusage_stats_length): * alloc.c (Fobject_memory_usage): * alloc.c (Ftotal_object_memory_usage): * alloc.c (malloced_storage_size): * alloc.c (common_init_alloc_early): * alloc.c (reinit_alloc_objects_early): * alloc.c (reinit_alloc_early): * alloc.c (init_alloc_once_early): * alloc.c (syms_of_alloc): * alloc.c (reinit_vars_of_alloc): * buffer.c: * buffer.c (struct buffer_stats): * buffer.c (compute_buffer_text_usage): * buffer.c (compute_buffer_usage): * buffer.c (buffer_memory_usage): * buffer.c (buffer_objects_create): * buffer.c (syms_of_buffer): * buffer.c (vars_of_buffer): * console-impl.h (struct console_methods): * dynarr.c (Dynarr_memory_usage): * emacs.c (main_1): * events.c (clear_event_resource): * extents.c: * extents.c (compute_buffer_extent_usage): * extents.c (extent_objects_create): * extents.h: * faces.c: * faces.c (compute_face_cachel_usage): * faces.c (face_objects_create): * faces.h: * general-slots.h: * glyphs.c: * glyphs.c (compute_glyph_cachel_usage): * glyphs.c (glyph_objects_create): * glyphs.h: * lisp.h: * lisp.h (struct usage_stats): * lrecord.h: * lrecord.h (enum lrecord_type): * lrecord.h (struct lrecord_implementation): * lrecord.h (MC_ALLOC_CALL_FINALIZER_FOR_DISKSAVE): * lrecord.h (DEFINE_DUMPABLE_LISP_OBJECT): * lrecord.h (DEFINE_DUMPABLE_SIZABLE_LISP_OBJECT): * lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_LISP_OBJECT): * lrecord.h (DEFINE_DUMPABLE_FROB_BLOCK_SIZABLE_LISP_OBJECT): * lrecord.h (DEFINE_DUMPABLE_INTERNAL_LISP_OBJECT): * lrecord.h (DEFINE_DUMPABLE_SIZABLE_INTERNAL_LISP_OBJECT): * lrecord.h (DEFINE_NODUMP_LISP_OBJECT): * lrecord.h (DEFINE_NODUMP_SIZABLE_LISP_OBJECT): * lrecord.h (DEFINE_NODUMP_FROB_BLOCK_LISP_OBJECT): * lrecord.h (DEFINE_NODUMP_FROB_BLOCK_SIZABLE_LISP_OBJECT): * lrecord.h (DEFINE_NODUMP_INTERNAL_LISP_OBJECT): * lrecord.h (DEFINE_NODUMP_SIZABLE_INTERNAL_LISP_OBJECT): * lrecord.h (MAKE_LISP_OBJECT): * lrecord.h (DEFINE_DUMPABLE_MODULE_LISP_OBJECT): * lrecord.h (DEFINE_DUMPABLE_MODULE_SIZABLE_LISP_OBJECT): * lrecord.h (DEFINE_NODUMP_MODULE_LISP_OBJECT): * lrecord.h (DEFINE_NODUMP_MODULE_SIZABLE_LISP_OBJECT): * lrecord.h (MAKE_MODULE_LISP_OBJECT): * lrecord.h (INIT_LISP_OBJECT): * lrecord.h (INIT_MODULE_LISP_OBJECT): * lrecord.h (UNDEF_LISP_OBJECT): * lrecord.h (UNDEF_MODULE_LISP_OBJECT): * lrecord.h (DECLARE_LISP_OBJECT): * lrecord.h (DECLARE_MODULE_API_LISP_OBJECT): * lrecord.h (DECLARE_MODULE_LISP_OBJECT): * lstream.c: * lstream.c (syms_of_lstream): * lstream.c (vars_of_lstream): * marker.c: * marker.c (compute_buffer_marker_usage): * mc-alloc.c (mc_alloced_storage_size): * mc-alloc.h: * mule-charset.c: * mule-charset.c (struct charset_stats): * mule-charset.c (compute_charset_usage): * mule-charset.c (charset_memory_usage): * mule-charset.c (mule_charset_objects_create): * mule-charset.c (syms_of_mule_charset): * mule-charset.c (vars_of_mule_charset): * redisplay.c: * redisplay.c (compute_rune_dynarr_usage): * redisplay.c (compute_display_block_dynarr_usage): * redisplay.c (compute_glyph_block_dynarr_usage): * redisplay.c (compute_display_line_dynarr_usage): * redisplay.c (compute_line_start_cache_dynarr_usage): * redisplay.h: * scrollbar-gtk.c (gtk_compute_scrollbar_instance_usage): * scrollbar-msw.c (mswindows_compute_scrollbar_instance_usage): * scrollbar-x.c (x_compute_scrollbar_instance_usage): * scrollbar.c (compute_scrollbar_instance_usage): * scrollbar.h: * symbols.c: * symbols.c (reinit_symbol_objects_early): * symbols.c (init_symbols_once_early): * symbols.c (reinit_symbols_early): * symbols.c (defsymbol_massage_name_1): * symsinit.h: * ui-gtk.c: * ui-gtk.c (emacs_gtk_object_getprop): * ui-gtk.c (emacs_gtk_object_putprop): * ui-gtk.c (ui_gtk_objects_create): * unicode.c (compute_from_unicode_table_size_1): * unicode.c (compute_to_unicode_table_size_1): * unicode.c (compute_from_unicode_table_size): * unicode.c (compute_to_unicode_table_size): * window.c: * window.c (struct window_stats): * window.c (compute_window_mirror_usage): * window.c (compute_window_usage): * window.c (window_memory_usage): * window.c (window_objects_create): * window.c (syms_of_window): * window.c (vars_of_window): * window.h: Redo memory-usage mechanism, make it general; add way of dynamically initializing Lisp object types -- OBJECT_HAS_METHOD(), similar to CONSOLE_HAS_METHOD(). (1) Create OBJECT_HAS_METHOD(), OBJECT_HAS_PROPERTY() etc. for specifying that a Lisp object type has a particular method or property. Call such methods with OBJECT_METH, MAYBE_OBJECT_METH, OBJECT_METH_OR_GIVEN; retrieve properties with OBJECT_PROPERTY. Methods that formerly required a DEFINE_*GENERAL_LISP_OBJECT() to specify them (getprop, putprop, remprop, plist, disksave) now instead use the dynamic-method mechanism. The main benefit of this is that new methods or properties can be added without requiring that the declaration statements of all existing methods be modified. We have to make the `struct lrecord_implementation' non-const, but I don't think this should have any effect on speed -- the only possible method that's really speed-critical is the mark method, and we already extract those out into a separate (non-const) array for increased cache locality. Object methods need to be reinitialized after pdump, so we put them in separate functions such as face_objects_create(), extent_objects_create() and call them appropriately from emacs.c The only current object property (`memusage_stats_list') that objects can specify is a Lisp object and gets staticpro()ed so it only needs to be set during dump time, but because it references symbols that might not exist in a syms_of_() function, we initialize it in vars_of_(). There is also an object property (`num_extra_memusage_stats') that is automatically initialized based on `memusage_stats_list'; we do that in reinit_vars_of_alloc(), which is called after all vars_of_() functions are called. `disksaver' method was renamed `disksave' to correspond with the name normally given to the function (e.g. disksave_lstream()). (2) Generalize the memory-usage mechanism in `buffer-memory-usage', `window-memory-usage', `charset-memory-usage' into an object-type- specific mechanism called by a single function `object-memory-usage'. (Former function `object-memory-usage' renamed to `total-object-memory-usage'). Generalize the mechanism of different "slices" so that we can have different "classes" of memory described and different "slices" onto each class; `t' separates classes, `nil' separates slices. Currently we have three classes defined: the memory of an object itself, non-Lisp-object memory associated with the object (e.g. arrays or dynarrs stored as fields in the object), and Lisp-object memory associated with the object (other internal Lisp objects stored in the object). This isn't completely finished yet and we might need to further separate the "other internal Lisp objects" class into two classes. The memory-usage mechanism uses a `struct usage_stats' (renamed from `struct overhead_stats') to describe a malloc-view onto a set of allocated memory (listing how much was requested and various types of overhead) and a more general `struct generic_usage_stats' (with a `struct usage_stats' in it) to hold all statistics about object memory. `struct generic_usage_stats' contains an array of 32 Bytecounts, which are statistics of unspecified semantics. The intention is that individual types declare a corresponding struct (e.g. `struct window_stats') with the same structure but with specific fields in place of the array, corresponding to specific statistics. The number of such statistics is an object property computed from the list of tags (Lisp symbols describing the statistics) stored in `memusage_stats_list'. The idea here is to allow particular object types to customize the number and semantics of the statistics where completely avoiding consing. This doesn't matter so much yet, but the intention is to have the memory usage of all objects computed at the end of GC, at the same time as other statistics are currently computed. The values for all statistics for a single type would be added up to compute aggregate values for all objects of a specific type. To make this efficient, we can't allow any memory allocation at all. (3) Create some additional functions for creating lists that specify the elements directly as args rather than indirectly through an array: listn() (number of args given), listu() (list terminated by Qunbound). (4) Delete a bit of remaining unused C window_config stuff, also unused lrecord_type_popup_data.

/* Definitions for bytecode interpretation and compiled-function objects.
   Copyright (C) 1985, 1986, 1987, 1992, 1993 Free Software Foundation, Inc.
   Copyright (C) 2002 Ben Wing.

This file is part of XEmacs.

XEmacs is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation; either version 2, or (at your option) any
later version.

XEmacs is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with XEmacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

/* Synched up with: Not in FSF. */

/* Authorship:

   FSF: long ago.
   Mly: rewrote for 19.8, properly abstracted.
   Jon Reid: some changes for I18N3 (domain, etc), for 19.8.
 */

#ifndef INCLUDED_bytecode_h_
#define INCLUDED_bytecode_h_

#ifdef NEW_GC
struct compiled_function_args
{
  NORMAL_LISP_OBJECT_HEADER header;
  long size;
  Lisp_Object args[1];
};

typedef struct compiled_function_args Lisp_Compiled_Function_Args;

DECLARE_LISP_OBJECT (compiled_function_args, Lisp_Compiled_Function_Args);

#define XCOMPILED_FUNCTION_ARGS(x) \
  XRECORD (x, compiled_function_args, Lisp_Compiled_Function_Args)
#define wrap_compiled_function_args(p) wrap_record (p, compiled_function_args)
#define COMPILED_FUNCTION_ARGS_P(x) RECORDP (x, compiled_function_args)
#define CHECK_COMPILED_FUNCTION_ARGS(x) \
  CHECK_RECORD (x, compiled_function_args)
#define CONCHECK_COMPILED_FUNCTION_ARGS(x) \
  CONCHECK_RECORD (x, compiled_function_args)

#define compiled_function_args_data(v) ((v)->args)
#define XCOMPILED_FUNCTION_ARGS_DATA(s) \
  compiled_function_args_data (XCOMPILED_FUNCTION_ARGS (s))
#endif /* NEW_GC */

/* Meanings of slots in a Lisp_Compiled_Function.
   Don't use these!  For backward compatibility only.  */
#define COMPILED_ARGLIST	0
#define COMPILED_INSTRUCTIONS	1
#define COMPILED_CONSTANTS	2
#define COMPILED_STACK_DEPTH	3
#define COMPILED_DOC_STRING	4
#define COMPILED_INTERACTIVE	5
#define COMPILED_DOMAIN		6

/* Someone claims: [[ It doesn't make sense to have this and also have
   load-history ]] But in fact they are quite different things.  Perhaps
   we should turn this on only when DEBUG_XEMACS but there's no speed
   harm at all, so no reason not to do it always. */
#define COMPILED_FUNCTION_ANNOTATION_HACK

#ifdef DEBUG_XEMACS
/* Define BYTE_CODE_METER to enable generation of a byte-op usage
   histogram.  This isn't defined in FSF Emacs and isn't defined in XEmacs
   v19.  But this is precisely the thing to turn on when DEBUG_XEMACS.  It
   may lead to a slight speed penalty but nothing major. */
#define BYTE_CODE_METER
#endif

struct Lisp_Compiled_Function
{
  FROB_BLOCK_LISP_OBJECT_HEADER lheader;
  unsigned short stack_depth;
  unsigned short specpdl_depth;
  struct
  {
    unsigned int documentationp: 1;
    unsigned int interactivep: 1;
    /* Only used if I18N3, but always defined for simplicity. */
    unsigned int domainp: 1;
    /* Non-zero if this bytecode came from a v18 or v19 file.
       We need to Ebolify the `assoc', `delq', etc. functions. */
    unsigned int ebolified: 1;
  } flags;
  Lisp_Object instructions;
  Lisp_Object constants;
  Lisp_Object arglist;
  /* For speed, we unroll arglist into an array of argument symbols, so we
     don't have to process arglist every time we make a function call. */
#ifdef NEW_GC
  Lisp_Object arguments;
#else /* not NEW_GC */
  Lisp_Object *args;
#endif /* not NEW_GC */
  /* Minimum and maximum number of arguments.  If MAX_ARGS == MANY, the
     function was declared with &rest, and (args_in_array - 1) indicates
     how many arguments there are before the &rest argument. (We could
     munge the max_non_rest_args into max_args by using a negative number,
     but that interferes with pdump marking.  We don't want to use a flag
     to indicate &rest because that would add an extra check in the
     simplest case.) */
  int min_args, max_args;
  int args_in_array;
  /* This uses the minimal number of conses; see accessors in data.c. */
  Lisp_Object doc_and_interactive;
#ifdef COMPILED_FUNCTION_ANNOTATION_HACK
  /* Something indicating where the bytecode came from */
  Lisp_Object annotated;
#endif
};
typedef struct Lisp_Compiled_Function Lisp_Compiled_Function;

Lisp_Object run_byte_code (Lisp_Object compiled_function_or_instructions, ...);

Lisp_Object compiled_function_arglist       (Lisp_Compiled_Function *f);
Lisp_Object compiled_function_instructions  (Lisp_Compiled_Function *f);
Lisp_Object compiled_function_constants     (Lisp_Compiled_Function *f);
int         compiled_function_stack_depth   (Lisp_Compiled_Function *f);
Lisp_Object compiled_function_documentation (Lisp_Compiled_Function *f);
Lisp_Object compiled_function_annotation    (Lisp_Compiled_Function *f);
Lisp_Object compiled_function_domain        (Lisp_Compiled_Function *f);
Lisp_Object compiled_function_interactive   (Lisp_Compiled_Function *f);

void set_compiled_function_documentation (Lisp_Compiled_Function *f,
					  Lisp_Object new_doc);

void optimize_compiled_function (Lisp_Object compiled_function);

typedef unsigned char Opbyte;
Lisp_Object execute_optimized_program (const Opbyte *program,
#ifdef ERROR_CHECK_BYTE_CODE
				       Elemcount program_length,
#endif
				       int stack_depth,
				       Lisp_Object *constants_data);

DECLARE_LISP_OBJECT (compiled_function, Lisp_Compiled_Function);
#define XCOMPILED_FUNCTION(x) XRECORD (x, compiled_function, \
				       Lisp_Compiled_Function)
#define wrap_compiled_function(p) wrap_record (p, compiled_function)
#define COMPILED_FUNCTIONP(x) RECORDP (x, compiled_function)
#define CHECK_COMPILED_FUNCTION(x) CHECK_RECORD (x, compiled_function)
#define CONCHECK_COMPILED_FUNCTION(x) CONCHECK_RECORD (x, compiled_function)

extern Lisp_Object Qbyte_code;

/* total 1765 internal 101 doc-and-int 775 doc-only 389 int-only 42 neither 559
 no doc slot, no int slot
    overhead                        : (* 1765 0) =    0
    doc-and-int (args . (doc . int)): (*  775 4) = 3100
    doc-only    (args . doc)        : (*  389 2) =  778
    int-only    (args . int)        : (*   42 2) =   84
    neither     args                : (*  559 0) =    0 = 3962
 combined
    overhead                        : (* 1765 1) = 1765
    doc-and-int (doc . int)         : (*  775 2) = 1550
    doc-only    doc                 : (*  389 0) =    0
    int-only    int                 : (*   42 0) =    0
    neither     -                   : (*  559 0) =    0 = 3315
 both
    overhead                        : (* 1765 2) = 3530
    doc-and-int -                   : (*  775 0) =    0
    doc-only    -                   : (*  389 0) =    0
    int-only    -                   : (*   42 0) =    0
    neither     -                   : (*  559 0)  =   0 = 3530
*/

#endif /* INCLUDED_bytecode_h_ */