/* * jmemmgr.c * * Copyright (C) 1991-1997, Thomas G. Lane. * This file is part of the Independent JPEG Group's software. * For conditions of distribution and use, see the accompanying README file. * * This file contains the JPEG system-independent memory management * routines.  This code is usable across a wide variety of machines; most * of the system dependencies have been isolated in a separate file. * The major functions provided here are: *   * pool-based allocation and freeing of memory; *   * policy decisions about how to divide available memory among the *     virtual arrays; *   * control logic for swapping virtual arrays between main memory and *     backing storage. * The separate system-dependent file provides the actual backing-storage * access code, and it contains the policy decision about how much total * main memory to use. * This file is system-dependent in the sense that some of its functions * are unnecessary in some systems.  For example, if there is enough virtual * memory so that backing storage will never be used, much of the virtual * array control logic could be removed.  (Of course, if you have that much * memory then you shouldn't care about a little bit of unused code...) */#define JPEG_INTERNALS#define AM_MEMORY_MANAGER	/* we define jvirt_Xarray_control structs */#include "jinclude.h"#include "jpeglib.h"#include "jmemsys.h"		/* import the system-dependent declarations */#ifndef NO_GETENV#ifndef HAVE_STDLIB_H		/* <stdlib.h> should declare getenv() *///extern char * getenv JPP((const char * name));#endif#endif/* * Some important notes: *   The allocation routines provided here must never return NULL. *   They should exit to error_exit if unsuccessful. * *   It's not a good idea to try to merge the sarray and barray routines, *   even though they are textually almost the same, because samples are *   usually stored as bytes while coefficients are shorts or ints.  Thus, *   in machines where byte pointers have a different representation from *   word pointers, the resulting machine code could not be the same. *//* * Many machines require storage alignment: longs must start on 4-byte * boundaries, doubles on 8-byte boundaries, etc.  On such machines, malloc() * always returns pointers that are multiples of the worst-case alignment * requirement, and we had better do so too. * There isn't any really portable way to determine the worst-case alignment * requirement.  This module assumes that the alignment requirement is * multiples of sizeof(ALIGN_TYPE). * By default, we define ALIGN_TYPE as double.  This is necessary on some * workstations (where doubles really do need 8-byte alignment) and will work * fine on nearly everything.  If your machine has lesser alignment needs, * you can save a few bytes by making ALIGN_TYPE smaller. * The only place I know of where this will NOT work is certain Macintosh * 680x0 compilers that define double as a 10-byte IEEE extended float. * Doing 10-byte alignment is counterproductive because longwords won't be * aligned well.  Put "#define ALIGN_TYPE long" in jconfig.h if you have * such a compiler. */#ifndef ALIGN_TYPE		/* so can override from jconfig.h */#define ALIGN_TYPE  double#endif/* * We allocate objects from "pools", where each pool is gotten with a single * request to jpeg_get_small() or jpeg_get_large().  There is no per-object * overhead within a pool, except for alignment padding.  Each pool has a * header with a link to the next pool of the same class. * Small and large pool headers are identical except that the latter's * link pointer must be FAR on 80x86 machines. * Notice that the "real" header fields are union'ed with a dummy ALIGN_TYPE * field.  This forces the compiler to make SIZEOF(small_pool_hdr) a multiple * of the alignment requirement of ALIGN_TYPE. */typedef union small_pool_struct * small_pool_ptr;typedef union small_pool_struct {  struct {    small_pool_ptr next;	/* next in list of pools */    size_t bytes_used;		/* how many bytes already used within pool */    size_t bytes_left;		/* bytes still available in this pool */  } hdr;  ALIGN_TYPE dummy;		/* included in union to ensure alignment */} small_pool_hdr;typedef union large_pool_struct FAR * large_pool_ptr;typedef union large_pool_struct {  struct {    large_pool_ptr next;	/* next in list of pools */    size_t bytes_used;		/* how many bytes already used within pool */    size_t bytes_left;		/* bytes still available in this pool */  } hdr;  ALIGN_TYPE dummy;		/* included in union to ensure alignment */} large_pool_hdr;/* * Here is the full definition of a memory manager object. */typedef struct {  struct jpeg_memory_mgr pub;	/* public fields */  /* Each pool identifier (lifetime class) names a linked list of pools. */  small_pool_ptr small_list[JPOOL_NUMPOOLS];  large_pool_ptr large_list[JPOOL_NUMPOOLS];  /* Since we only have one lifetime class of virtual arrays, only one   * linked list is necessary (for each datatype).  Note that the virtual   * array control blocks being linked together are actually stored somewhere   * in the small-pool list.   */  jvirt_sarray_ptr virt_sarray_list;  jvirt_barray_ptr virt_barray_list;  /* This counts total space obtained from jpeg_get_small/large */  long total_space_allocated;  /* alloc_sarray and alloc_barray set this value for use by virtual   * array routines.   */  JDIMENSION last_rowsperchunk;	/* from most recent alloc_sarray/barray */} my_memory_mgr;typedef my_memory_mgr * my_mem_ptr;/* * The control blocks for virtual arrays. * Note that these blocks are allocated in the "small" pool area. * System-dependent info for the associated backing store (if any) is hidden * inside the backing_store_info struct. */struct jvirt_sarray_control {  JSAMPARRAY mem_buffer;	/* => the in-memory buffer */  JDIMENSION rows_in_array;	/* total virtual array height */  JDIMENSION samplesperrow;	/* width of array (and of memory buffer) */  JDIMENSION maxaccess;		/* max rows accessed by access_virt_sarray */  JDIMENSION rows_in_mem;	/* height of memory buffer */  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */  JDIMENSION cur_start_row;	/* first logical row # in the buffer */  JDIMENSION first_undef_row;	/* row # of first uninitialized row */  boolean pre_zero;		/* pre-zero mode requested? */  boolean dirty;		/* do current buffer contents need written? */  boolean b_s_open;		/* is backing-store data valid? */  jvirt_sarray_ptr next;	/* link to next virtual sarray control block */  backing_store_info b_s_info;	/* System-dependent control info */};struct jvirt_barray_control {  JBLOCKARRAY mem_buffer;	/* => the in-memory buffer */  JDIMENSION rows_in_array;	/* total virtual array height */  JDIMENSION blocksperrow;	/* width of array (and of memory buffer) */  JDIMENSION maxaccess;		/* max rows accessed by access_virt_barray */  JDIMENSION rows_in_mem;	/* height of memory buffer */  JDIMENSION rowsperchunk;	/* allocation chunk size in mem_buffer */  JDIMENSION cur_start_row;	/* first logical row # in the buffer */  JDIMENSION first_undef_row;	/* row # of first uninitialized row */  boolean pre_zero;		/* pre-zero mode requested? */  boolean dirty;		/* do current buffer contents need written? */  boolean b_s_open;		/* is backing-store data valid? */  jvirt_barray_ptr next;	/* link to next virtual barray control block */  backing_store_info b_s_info;	/* System-dependent control info */};#ifdef MEM_STATS		/* optional extra stuff for statistics */LOCAL(void)print_mem_stats (j_common_ptr cinfo, int pool_id){#if 0  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  small_pool_ptr shdr_ptr;  large_pool_ptr lhdr_ptr;  /* Since this is only a debugging stub, we can cheat a little by using   * fprintf directly rather than going through the trace message code.   * This is helpful because message parm array can't handle longs.   *///  fprintf(stderr, "Freeing pool %d, total space = %ld\n",//	  pool_id, mem->total_space_allocated);  for (lhdr_ptr = mem->large_list[pool_id]; lhdr_ptr != NULL;       lhdr_ptr = lhdr_ptr->hdr.next) {//    fprintf(stderr, "  Large chunk used %ld\n",//	    (long) lhdr_ptr->hdr.bytes_used);  }  for (shdr_ptr = mem->small_list[pool_id]; shdr_ptr != NULL;       shdr_ptr = shdr_ptr->hdr.next) {//    fprintf(stderr, "  Small chunk used %ld free %ld\n",//	    (long) shdr_ptr->hdr.bytes_used,//	    (long) shdr_ptr->hdr.bytes_left);  }#endif }#endif /* MEM_STATS */LOCAL(void)out_of_memory (j_common_ptr cinfo, int which)/* Report an out-of-memory error and stop execution *//* If we compiled MEM_STATS support, report alloc requests before dying */{#ifdef MEM_STATS  cinfo->err->trace_level = 2;	/* force self_destruct to report stats */#endif  ERREXIT1(cinfo, JERR_OUT_OF_MEMORY, which);}/* * Allocation of "small" objects. * * For these, we use pooled storage.  When a new pool must be created, * we try to get enough space for the current request plus a "slop" factor, * where the slop will be the amount of leftover space in the new pool. * The speed vs. space tradeoff is largely determined by the slop values. * A different slop value is provided for each pool class (lifetime), * and we also distinguish the first pool of a class from later ones. * NOTE: the values given work fairly well on both 16- and 32-bit-int * machines, but may be too small if longs are 64 bits or more. */static const size_t first_pool_slop[JPOOL_NUMPOOLS] = {	1600,			/* first PERMANENT pool */	16000			/* first IMAGE pool */};static const size_t extra_pool_slop[JPOOL_NUMPOOLS] = {	0,			/* additional PERMANENT pools */	5000			/* additional IMAGE pools */};#define MIN_SLOP  50		/* greater than 0 to avoid futile looping */METHODDEF(void *)alloc_small (j_common_ptr cinfo, int pool_id, size_t sizeofobject)/* Allocate a "small" object */{  my_mem_ptr mem = (my_mem_ptr) cinfo->mem;  small_pool_ptr hdr_ptr, prev_hdr_ptr;  char * data_ptr;  size_t odd_bytes, min_request, slop;  //pwhsu:20031013  This isn't the procedure of alloc_small  /* Check for unsatisfiable request (do now to ensure no overflow below) */  if (sizeofobject > (size_t) (MAX_ALLOC_CHUNK-SIZEOF(small_pool_hdr)))    out_of_memory(cinfo, 1);	/* request exceeds malloc's ability */  //pwhsu:20031013  干Θdouble