The perl source is shipped with a version of malloc that is very fast
but somewhat wasteful of space. On the other hand, your system's
malloc() function may be a bit slower but also a bit more frugal.
+However, note that space efficiency also contributes to speed efficiency,
+so there's a chance that perl's malloc may be more efficient both
+space and speed wise.
For many uses, speed is probably the most important consideration, so
the default behavior (for most systems) is to use the malloc supplied
(e.g. Tk or PDL) or if your system already has an excellent malloc, or
if you are experiencing difficulties with extensions that use
third-party libraries that call malloc, then you might wish to use
-your system's malloc. (Or, you might wish to explore the experimental
-malloc flags discussed below.)
+your system's malloc. (Or, you might wish to explore the malloc flags
+discussed below.)
To build without perl's malloc, you can use the Configure command
=head2 Malloc Performance Flags
-If you are using Perl's malloc, you may add one or
-more of the following items to your cflags config.sh variable
-to change its behavior in potentially useful ways. You can find out
-more about these flags by reading the malloc.c source.
-In a future version of perl, these might be enabled by default.
+If you are using Perl's malloc, you may add one or more of the following
+items to your cflags config.sh variable to change its behavior. You can
+find out more about these and other flags by reading the commentary near
+the top of the malloc.c source.
=over 4
-=item -DPERL_EMERGENCY_SBRK
+=item -DNO_FANCY_MALLOC
-If PERL_EMERGENCY_SBRK is defined, running out of memory need not be a
-fatal error: a memory pool can allocated by assigning to the special
-variable $^M. See perlvar(1) for more details.
+Undefined by default. Defining it returns malloc to the state it was at
+in Perl version 5.004.
-=item -DPACK_MALLOC
+If left undefined, it enables -DBUCKETS_ROOT2, -DIGNORE_SMALL_BAD_FREE,
+and -DSMALL_BUCKET_VIA_VTABLE. See the commentary in malloc.c for more
+details.
-If PACK_MALLOC is defined, malloc.c uses a slightly different
-algorithm for small allocations (up to 64 bytes long). Such small
-allocations are quite common in typical Perl scripts.
+=item -DPLAIN_MALLOC
-The expected memory savings (with 8-byte alignment in $alignbytes) is
-about 20% for typical Perl usage. The expected slowdown due to the
-additional malloc overhead is in fractions of a percent. (It is hard
-to measure because of the effect of the saved memory on speed).
+Undefined by default. Defining it in addition to NO_FANCY_MALLOC returns
+malloc to the state it was at in Perl version 5.000.
-=item -DTWO_POT_OPTIMIZE
-
-If TWO_POT_OPTIMIZE is defined, malloc.c uses a slightly different
-algorithm for large allocations that are close to a power of two
-(starting with 16K). Such allocations are typical for big hashes and
-special-purpose scripts, especially image processing. If you will be
-manipulating very large blocks with sizes close to powers of two, it
-might be wise to define this macro.
-
-The expected saving of memory is 0-100% (100% in applications which
-require most memory in such 2**n chunks). The expected slowdown is
-negligible.
+If left undefined, it enables -DPERL_EMERGENCY_SBRK, -DPACK_MALLOC,
+-DTWO_POT_OPTIMIZE, and -DDEBUGGING_MSTATS. See the commentary in
+malloc.c for more details.
=back
*
*/
+/*
+ Here are some notes on configuring Perl's malloc.
+
+ There are two macros which serve as bulk disablers of advanced
+ features of this malloc: NO_FANCY_MALLOC, PLAIN_MALLOC (undef by
+ default). Look in the list of default values below to understand
+ their exact effect. Defining NO_FANCY_MALLOC returns malloc.c to the
+ state of the malloc in Perl 5.004. Additionally defining PLAIN_MALLOC
+ returns it to the state as of Perl 5.000.
+
+ Note that some of the settings below may be ignored in the code based
+ on values of other macros. The PERL_CORE symbol is only defined when
+ perl itself is being compiled (so malloc can make some assumptions
+ about perl's facilities being available to it).
+
+ Each config option has a short description, followed by its name,
+ default value, and a comment about the default (if applicable). Some
+ options take a precise value, while the others are just boolean.
+ The boolean ones are listed first.
+
+ # Enable code for an emergency memory pool in $^M. See perlvar.pod
+ # for a description of $^M.
+ PERL_EMERGENCY_SBRK (!PLAIN_MALLOC && PERL_CORE)
+
+ # Enable code for printing memory statistics.
+ DEBUGGING_MSTATS (!PLAIN_MALLOC && PERL_CORE)
+
+ # Move allocation info for small buckets into separate areas.
+ # Memory optimization (especially for small allocations, of the
+ # less than 64 bytes). Since perl usually makes a large number
+ # of small allocations, this is usually a win.
+ PACK_MALLOC (!PLAIN_MALLOC && !RCHECK)
+
+ # Add one page to big powers of two when calculating bucket size.
+ # This is targeted at big allocations, as are common in image
+ # processing.
+ TWO_POT_OPTIMIZE !PLAIN_MALLOC
+
+ # Use intermediate bucket sizes between powers-of-two. This is
+ # generally a memory optimization, and a (small) speed pessimization.
+ BUCKETS_ROOT2 !NO_FANCY_MALLOC
+
+ # Do not check small deallocations for bad free(). Memory
+ # and speed optimization, error reporting pessimization.
+ IGNORE_SMALL_BAD_FREE (!NO_FANCY_MALLOC && !RCHECK)
+
+ # Use table lookup to decide in which bucket a given allocation will go.
+ SMALL_BUCKET_VIA_TABLE !NO_FANCY_MALLOC
+
+ # Use system-malloc() to emulate sbrk(). Normally only used with broken
+ # sbrk()s.
+ PERL_SBRK_VIA_MALLOC undef
+
+ # Disable memory overwrite checking with DEBUGGING. Memory and speed
+ # optimization, error reporting pessimization.
+ NO_RCHECK undef
+
+ # Enable memory overwrite checking with DEBUGGING. Memory and speed
+ # pessimization, error reporting optimization
+ RCHECK (DEBUGGING && !NO_RCHECK)
+
+ # Failed allocations bigger than this size croak (if
+ # PERL_EMERGENCY_SBRK is enabled) without touching $^M. See
+ # perlvar.pod for a description of $^M.
+ BIG_SIZE (1<<16) # 64K
+
+ # Starting from this power of two, add an extra page to the
+ # size of the bucket. This enables optimized allocations of sizes
+ # close to powers of 2. Note that the value is indexed at 0.
+ FIRST_BIG_POW2 15 # 32K, 16K is used too often
+
+ # Estimate of minimal memory footprint. malloc uses this value to
+ # request the most reasonable largest blocks of memory from the system.
+ FIRST_SBRK (48*1024)
+
+ # Round up sbrk()s to multiples of this.
+ MIN_SBRK 2048
+
+ # Round up sbrk()s to multiples of this percent of footprint.
+ MIN_SBRK_FRAC 3
+
+ # Add this much memory to big powers of two to get the bucket size.
+ PERL_PAGESIZE 4096
+
+ # This many sbrk() discontinuities should be tolerated even
+ # from the start without deciding that sbrk() is usually
+ # discontinuous.
+ SBRK_ALLOW_FAILURES 3
+
+ # This many continuous sbrk()s compensate for one discontinuous one.
+ SBRK_FAILURE_PRICE 50
+
+ # Which allocator to use if PERL_SBRK_VIA_MALLOC
+ SYSTEM_ALLOC(a) malloc(a)
+
+ This implementation assumes that calling PerlIO_printf() does not
+ result in any memory allocation calls (used during a panic).
+
+ */
+
#ifndef NO_FANCY_MALLOC
# ifndef SMALL_BUCKET_VIA_TABLE
# define SMALL_BUCKET_VIA_TABLE
projects / platform / upstream / perl.git / commitdiff