mem0mem.h

Go to the documentation of this file.

/*****************************************************************************

Copyright (c) 1994, 2010, Oracle and/or its affiliates. All Rights Reserved.

This program 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; version 2 of the License.

This program 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
this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Suite 500, Boston, MA 02110-1335 USA

*****************************************************************************/

/**************************************************/
#ifndef mem0mem_h
#define mem0mem_h

#include "univ.i"
#include "ut0mem.h"
#include "ut0byte.h"
#include "ut0rnd.h"
#ifndef UNIV_HOTBACKUP
# include "sync0sync.h"
#endif /* UNIV_HOTBACKUP */
#include "ut0lst.h"
#include "mach0data.h"

/* -------------------- MEMORY HEAPS ----------------------------- */

/* A block of a memory heap consists of the info structure
followed by an area of memory */
typedef struct mem_block_info_t mem_block_t;

/* A memory heap is a nonempty linear list of memory blocks */
typedef mem_block_t             mem_heap_t;

/* Types of allocation for memory heaps: DYNAMIC means allocation from the
dynamic memory pool of the C compiler, BUFFER means allocation from the
buffer pool; the latter method is used for very big heaps */

#define MEM_HEAP_DYNAMIC        0       /* the most common type */
#define MEM_HEAP_BUFFER         1
#define MEM_HEAP_BTR_SEARCH     2       /* this flag can optionally be
                                        ORed to MEM_HEAP_BUFFER, in which
                                        case heap->free_block is used in
                                        some cases for memory allocations,
                                        and if it's NULL, the memory
                                        allocation functions can return
                                        NULL. */

/* Different type of heaps in terms of which datastructure is using them */
#define MEM_HEAP_FOR_BTR_SEARCH         (MEM_HEAP_BTR_SEARCH | MEM_HEAP_BUFFER)
#define MEM_HEAP_FOR_PAGE_HASH          (MEM_HEAP_DYNAMIC)
#define MEM_HEAP_FOR_RECV_SYS           (MEM_HEAP_BUFFER)
#define MEM_HEAP_FOR_LOCK_HEAP          (MEM_HEAP_BUFFER)

/* The following start size is used for the first block in the memory heap if
the size is not specified, i.e., 0 is given as the parameter in the call of
create. The standard size is the maximum (payload) size of the blocks used for
allocations of small buffers. */

#define MEM_BLOCK_START_SIZE            64
#define MEM_BLOCK_STANDARD_SIZE         \
        (UNIV_PAGE_SIZE >= 16384 ? 8000 : MEM_MAX_ALLOC_IN_BUF)

/* If a memory heap is allowed to grow into the buffer pool, the following
is the maximum size for a single allocated buffer: */
#define MEM_MAX_ALLOC_IN_BUF            (UNIV_PAGE_SIZE - 200)

/******************************************************************/
UNIV_INTERN
void
mem_init(
/*=====*/
        ulint   size);  
/******************************************************************/
UNIV_INTERN
void
mem_close(void);
/*===========*/

#ifdef UNIV_DEBUG
/**************************************************************/
# define mem_heap_create(N)     mem_heap_create_func(           \
                (N), __FILE__, __LINE__, MEM_HEAP_DYNAMIC)
/**************************************************************/
# define mem_heap_create_typed(N, T)    mem_heap_create_func(   \
                (N), __FILE__, __LINE__, (T))

#else /* UNIV_DEBUG */
/**************************************************************/
# define mem_heap_create(N)     mem_heap_create_func(           \
                (N), MEM_HEAP_DYNAMIC)
/**************************************************************/
# define mem_heap_create_typed(N, T)    mem_heap_create_func(   \
                (N), (T))

#endif /* UNIV_DEBUG */
/**************************************************************/
#define mem_heap_free(heap) mem_heap_free_func(\
                                          (heap), __FILE__, __LINE__)
/*****************************************************************/
UNIV_INLINE
mem_heap_t*
mem_heap_create_func(
/*=================*/
        ulint           n,              
#ifdef UNIV_DEBUG
        const char*     file_name,      
        ulint           line,           
#endif /* UNIV_DEBUG */
        ulint           type);          
/*****************************************************************/
UNIV_INLINE
void
mem_heap_free_func(
/*===============*/
        mem_heap_t*     heap,           
        const char*     file_name,      
        ulint           line);          
/***************************************************************/
UNIV_INLINE
void*
mem_heap_zalloc(
/*============*/
        mem_heap_t*     heap,   
        ulint           n);     
/***************************************************************/
UNIV_INLINE
void*
mem_heap_alloc(
/*===========*/
        mem_heap_t*     heap,   
        ulint           n);     
/*****************************************************************/
UNIV_INLINE
byte*
mem_heap_get_heap_top(
/*==================*/
        mem_heap_t*     heap);  
/*****************************************************************/
UNIV_INLINE
void
mem_heap_free_heap_top(
/*===================*/
        mem_heap_t*     heap,   
        byte*           old_top);
/*****************************************************************/
UNIV_INLINE
void
mem_heap_empty(
/*===========*/
        mem_heap_t*     heap);  
/*****************************************************************/
UNIV_INLINE
void*
mem_heap_get_top(
/*=============*/
        mem_heap_t*     heap,   
        ulint           n);     
/*****************************************************************/
UNIV_INLINE
void
mem_heap_free_top(
/*==============*/
        mem_heap_t*     heap,   
        ulint           n);     
/*****************************************************************/
UNIV_INLINE
ulint
mem_heap_get_size(
/*==============*/
        mem_heap_t*     heap);          
/**************************************************************/
#define mem_zalloc(N)   memset(mem_alloc(N), 0, (N))

#ifdef UNIV_DEBUG
#define mem_alloc(N)    mem_alloc_func((N), __FILE__, __LINE__, NULL)
#define mem_alloc2(N,S) mem_alloc_func((N), __FILE__, __LINE__, (S))
#else /* UNIV_DEBUG */
#define mem_alloc(N)    mem_alloc_func((N), NULL)
#define mem_alloc2(N,S) mem_alloc_func((N), (S))
#endif /* UNIV_DEBUG */

/***************************************************************/
UNIV_INLINE
void*
mem_alloc_func(
/*===========*/
        ulint           n,              
#ifdef UNIV_DEBUG
        const char*     file_name,      
        ulint           line,           
#endif /* UNIV_DEBUG */
        ulint*          size);          
/**************************************************************/
#define mem_free(PTR)   mem_free_func((PTR), __FILE__, __LINE__)
/***************************************************************/
UNIV_INLINE
void
mem_free_func(
/*==========*/
        void*           ptr,            
        const char*     file_name,      
        ulint           line);          
/**********************************************************************/
UNIV_INLINE
char*
mem_strdup(
/*=======*/
        const char*     str);   
/**********************************************************************/
UNIV_INLINE
char*
mem_strdupl(
/*========*/
        const char*     str,    
        ulint           len);   
/**********************************************************************/
UNIV_INTERN
char*
mem_heap_strdup(
/*============*/
        mem_heap_t*     heap,   
        const char*     str);   
/**********************************************************************/
UNIV_INLINE
char*
mem_heap_strdupl(
/*=============*/
        mem_heap_t*     heap,   
        const char*     str,    
        ulint           len);   
/**********************************************************************/
UNIV_INTERN
char*
mem_heap_strcat(
/*============*/
        mem_heap_t*     heap,   
        const char*     s1,     
        const char*     s2);    
/**********************************************************************/
UNIV_INTERN
void*
mem_heap_dup(
/*=========*/
        mem_heap_t*     heap,   
        const void*     data,   
        ulint           len);   
/****************************************************************/
UNIV_INTERN
char*
mem_heap_printf(
/*============*/
        mem_heap_t*     heap,   
        const char*     format, 
        ...) __attribute__ ((format (printf, 2, 3)));

#ifdef MEM_PERIODIC_CHECK
/******************************************************************/
UNIV_INTERN
void
mem_validate_all_blocks(void);
/*=========================*/
#endif

/*#######################################################################*/

struct mem_block_info_t {
        ulint   magic_n;/* magic number for debugging */
#ifdef UNIV_DEBUG
        char    file_name[8];/* file name where the mem heap was created */
        ulint   line;   
#endif /* UNIV_DEBUG */
        UT_LIST_BASE_NODE_T(mem_block_t) base; /* In the first block in the
                        the list this is the base node of the list of blocks;
                        in subsequent blocks this is undefined */
        UT_LIST_NODE_T(mem_block_t) list; /* This contains pointers to next
                        and prev in the list. The first block allocated
                        to the heap is also the first block in this list,
                        though it also contains the base node of the list. */
        ulint   len;    
        ulint   total_size; 
        ulint   type;   
        ulint   free;   
        ulint   start;  
#ifndef UNIV_HOTBACKUP
        void*   free_block;
                        /* if the MEM_HEAP_BTR_SEARCH bit is set in type,
                        and this is the heap root, this can contain an
                        allocated buffer frame, which can be appended as a
                        free block to the heap, if we need more space;
                        otherwise, this is NULL */
        void*   buf_block;
                        /* if this block has been allocated from the buffer
                        pool, this contains the buf_block_t handle;
                        otherwise, this is NULL */
#endif /* !UNIV_HOTBACKUP */
#ifdef MEM_PERIODIC_CHECK
        UT_LIST_NODE_T(mem_block_t) mem_block_list;
                        /* List of all mem blocks allocated; protected
                        by the mem_comm_pool mutex */
#endif
};

#define MEM_BLOCK_MAGIC_N       764741555
#define MEM_FREED_BLOCK_MAGIC_N 547711122

/* Header size for a memory heap block */
#define MEM_BLOCK_HEADER_SIZE   ut_calc_align(sizeof(mem_block_info_t),\
                                                        UNIV_MEM_ALIGNMENT)
#include "mem0dbg.h"

#ifndef UNIV_NONINL
#include "mem0mem.ic"
#endif

#endif