Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

mysql/src/5.1-dbg/storage/innobase/mem/mem0pool.c File Reference

#include "mem0pool.h"
#include "sync0sync.h"
#include "ut0mem.h"
#include "ut0lst.h"
#include "ut0byte.h"
#include "mem0mem.h"

Include dependency graph for mem0pool.c:

Go to the source code of this file.

Classes
struct	mem_pool_struct
Defines
#define	MEM_AREA_FREE   1
#define	MEM_AREA_MIN_SIZE   (2 * MEM_AREA_EXTRA_SIZE)
Functions
void	mem_pool_mutex_enter (void)
void	mem_pool_mutex_exit (void)
UNIV_INLINE ulint	mem_area_get_size (mem_area_t *area)
UNIV_INLINE void	mem_area_set_size (mem_area_t *area, ulint size)
UNIV_INLINE ibool	mem_area_get_free (mem_area_t *area)
UNIV_INLINE void	mem_area_set_free (mem_area_t *area, ibool free)
mem_pool_t *	mem_pool_create (ulint size)
static ibool	mem_pool_fill_free_list (ulint i, mem_pool_t *pool)
void *	mem_area_alloc (ulint size, mem_pool_t *pool)
UNIV_INLINE mem_area_t *	mem_area_get_buddy (mem_area_t *area, ulint size, mem_pool_t *pool)
void	mem_area_free (void *ptr, mem_pool_t *pool)
ibool	mem_pool_validate (mem_pool_t *pool)
void	mem_pool_print_info (FILE *outfile, mem_pool_t *pool)
ulint	mem_pool_get_reserved (mem_pool_t *pool)
Variables
mem_pool_t *	mem_comm_pool = NULL
ulint	mem_n_threads_inside = 0

---

Define Documentation

#define MEM_AREA_FREE   1

Definition at line 77 of file mem0pool.c.

Referenced by mem_area_get_free(), mem_area_get_size(), mem_area_set_free(), and mem_area_set_size().

#define MEM_AREA_MIN_SIZE   (2 * MEM_AREA_EXTRA_SIZE)

Definition at line 80 of file mem0pool.c.

Referenced by mem_area_alloc(), and mem_pool_create().

---

Function Documentation

void* mem_area_alloc	(	ulint	size,
		mem_pool_t *	pool
	)

Definition at line 322 of file mem0pool.c.

References FALSE, mem_pool_struct::free_list, mem_analyze_corruption(), MEM_AREA_EXTRA_SIZE, mem_area_get_free(), mem_area_get_size(), MEM_AREA_MIN_SIZE, mem_area_set_free(), mem_n_threads_inside, mem_pool_fill_free_list(), mem_pool_validate(), mem_pool_struct::mutex, mutex_enter, mutex_exit(), n, NULL, mem_pool_struct::reserved, ut_2_exp(), ut_2_log(), ut_a, ut_ad, ut_error, UT_LIST_GET_FIRST, UT_LIST_GET_LEN, UT_LIST_REMOVE, ut_malloc(), and ut_max().

Referenced by mem_heap_create_block().

                                           : allocated memory buffer */
        ulint           size,   /* in: allocated size in bytes; for optimum
                                space usage, the size should be a power of 2
                                minus MEM_AREA_EXTRA_SIZE */
        mem_pool_t*     pool)   /* in: memory pool */
{
        mem_area_t*     area;
        ulint           n;
        ibool           ret;

        n = ut_2_log(ut_max(size + MEM_AREA_EXTRA_SIZE, MEM_AREA_MIN_SIZE));

        mutex_enter(&(pool->mutex));
        mem_n_threads_inside++;

        ut_a(mem_n_threads_inside == 1);

        area = UT_LIST_GET_FIRST(pool->free_list[n]);

        if (area == NULL) {
                ret = mem_pool_fill_free_list(n, pool);

                if (ret == FALSE) {
                        /* Out of memory in memory pool: we try to allocate
                        from the operating system with the regular malloc: */

                        mem_n_threads_inside--;
                        mutex_exit(&(pool->mutex));

                        return(ut_malloc(size));
                }

                area = UT_LIST_GET_FIRST(pool->free_list[n]);
        }

        if (!mem_area_get_free(area)) {
                fprintf(stderr,
"InnoDB: Error: Removing element from mem pool free list %lu though the\n"
"InnoDB: element is not marked free!\n",
                        (ulong) n);

                mem_analyze_corruption(area);

                /* Try to analyze a strange assertion failure reported at
                mysql@lists.mysql.com where the free bit IS 1 in the
                hex dump above */

                if (mem_area_get_free(area)) {
                        fprintf(stderr,
"InnoDB: Probably a race condition because now the area is marked free!\n");
                }

                ut_error;
        }

        if (UT_LIST_GET_LEN(pool->free_list[n]) == 0) {
                fprintf(stderr,
"InnoDB: Error: Removing element from mem pool free list %lu\n"
"InnoDB: though the list length is 0!\n",
                        (ulong) n);
                mem_analyze_corruption(area);

                ut_error;
        }

        ut_ad(mem_area_get_size(area) == ut_2_exp(n));

        mem_area_set_free(area, FALSE);

        UT_LIST_REMOVE(free_list, pool->free_list[n], area);

        pool->reserved += mem_area_get_size(area);

        mem_n_threads_inside--;
        mutex_exit(&(pool->mutex));

        ut_ad(mem_pool_validate(pool));

        return((void*)(MEM_AREA_EXTRA_SIZE + ((byte*)area)));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mem_area_free	(	void *	ptr,
		mem_pool_t *	pool
	)

Definition at line 449 of file mem0pool.c.

References mem_pool_struct::buf, FALSE, mem_pool_struct::free_list, mem_analyze_corruption(), MEM_AREA_EXTRA_SIZE, mem_area_free(), mem_area_get_buddy(), mem_area_get_free(), mem_area_get_size(), mem_area_set_free(), mem_area_set_size(), mem_n_threads_inside, mem_pool_validate(), mem_pool_struct::mutex, mutex_enter, mutex_exit(), n, mem_pool_struct::reserved, mem_pool_struct::size, TRUE, ut_2_exp(), ut_2_log(), ut_2_power_up(), ut_a, ut_ad, ut_error, ut_free(), UT_LIST_ADD_FIRST, and UT_LIST_REMOVE.

Referenced by mem_area_free(), and mem_heap_block_free().

                                          : pointer to allocated memory
                                buffer */
        mem_pool_t*     pool)   /* in: memory pool */
{
        mem_area_t*     area;
        mem_area_t*     buddy;
        void*           new_ptr;
        ulint           size;
        ulint           n;

        /* It may be that the area was really allocated from the OS with
        regular malloc: check if ptr points within our memory pool */

        if ((byte*)ptr < pool->buf || (byte*)ptr >= pool->buf + pool->size) {
                ut_free(ptr);

                return;
        }

        area = (mem_area_t*) (((byte*)ptr) - MEM_AREA_EXTRA_SIZE);

        if (mem_area_get_free(area)) {
                fprintf(stderr,
"InnoDB: Error: Freeing element to mem pool free list though the\n"
"InnoDB: element is marked free!\n");

                mem_analyze_corruption(area);
                ut_error;
        }

        size = mem_area_get_size(area);

        if (size == 0) {
                fprintf(stderr,
"InnoDB: Error: Mem area size is 0. Possibly a memory overrun of the\n"
"InnoDB: previous allocated area!\n");

                mem_analyze_corruption(area);
                ut_error;
        }

#ifdef UNIV_LIGHT_MEM_DEBUG
        if (((byte*)area) + size < pool->buf + pool->size) {

                ulint   next_size;

                next_size = mem_area_get_size(
                                        (mem_area_t*)(((byte*)area) + size));
                if (ut_2_power_up(next_size) != next_size) {
                        fprintf(stderr,
"InnoDB: Error: Memory area size %lu, next area size %lu not a power of 2!\n"
"InnoDB: Possibly a memory overrun of the buffer being freed here.\n",
                          (ulong) size, (ulong) next_size);
                        mem_analyze_corruption(area);

                        ut_error;
                }
        }
#endif
        buddy = mem_area_get_buddy(area, size, pool);

        n = ut_2_log(size);

        mutex_enter(&(pool->mutex));
        mem_n_threads_inside++;

        ut_a(mem_n_threads_inside == 1);

        if (buddy && mem_area_get_free(buddy)
                                && (size == mem_area_get_size(buddy))) {

                /* The buddy is in a free list */

                if ((byte*)buddy < (byte*)area) {
                        new_ptr = ((byte*)buddy) + MEM_AREA_EXTRA_SIZE;

                        mem_area_set_size(buddy, 2 * size);
                        mem_area_set_free(buddy, FALSE);
                } else {
                        new_ptr = ptr;

                        mem_area_set_size(area, 2 * size);
                }

                /* Remove the buddy from its free list and merge it to area */

                UT_LIST_REMOVE(free_list, pool->free_list[n], buddy);

                pool->reserved += ut_2_exp(n);

                mem_n_threads_inside--;
                mutex_exit(&(pool->mutex));

                mem_area_free(new_ptr, pool);

                return;
        } else {
                UT_LIST_ADD_FIRST(free_list, pool->free_list[n], area);

                mem_area_set_free(area, TRUE);

                ut_ad(pool->reserved >= size);

                pool->reserved -= size;
        }

        mem_n_threads_inside--;
        mutex_exit(&(pool->mutex));

        ut_ad(mem_pool_validate(pool));
}

Here is the call graph for this function:

Here is the caller graph for this function:

UNIV_INLINE mem_area_t* mem_area_get_buddy	(	mem_area_t *	area,
		ulint	size,
		mem_pool_t *	pool
	)

Definition at line 409 of file mem0pool.c.

References mem_pool_struct::buf, NULL, mem_pool_struct::size, and ut_ad.

Referenced by mem_area_free(), and mem_pool_validate().

                                      : the buddy, NULL if no buddy in pool */
        mem_area_t*     area,   /* in: memory area */
        ulint           size,   /* in: memory area size */
        mem_pool_t*     pool)   /* in: memory pool */
{
        mem_area_t*     buddy;

        ut_ad(size != 0);

        if (((((byte*)area) - pool->buf) % (2 * size)) == 0) {

                /* The buddy is in a higher address */

                buddy = (mem_area_t*)(((byte*)area) + size);

                if ((((byte*)buddy) - pool->buf) + size > pool->size) {

                        /* The buddy is not wholly contained in the pool:
                        there is no buddy */

                        buddy = NULL;
                }
        } else {
                /* The buddy is in a lower address; NOTE that area cannot
                be at the pool lower end, because then we would end up to
                the upper branch in this if-clause: the remainder would be
                0 */

                buddy = (mem_area_t*)(((byte*)area) - size);
        }

        return(buddy);
}

Here is the caller graph for this function:

UNIV_INLINE ibool mem_area_get_free

(

mem_area_t *

area

)

Definition at line 155 of file mem0pool.c.

References MEM_AREA_FREE, and mem_area_struct::size_and_free.

Referenced by mem_area_alloc(), mem_area_free(), and mem_pool_validate().

                                      : TRUE if free */
        mem_area_t*     area)   /* in: area */
{
#if TRUE != MEM_AREA_FREE
# error "TRUE != MEM_AREA_FREE"
#endif
        return(area->size_and_free & MEM_AREA_FREE);
}

Here is the caller graph for this function:

UNIV_INLINE ulint mem_area_get_size

(

mem_area_t *

area

)

Definition at line 130 of file mem0pool.c.

References MEM_AREA_FREE, and mem_area_struct::size_and_free.

Referenced by mem_area_alloc(), mem_area_free(), and mem_pool_validate().

                                      : size */
        mem_area_t*     area)   /* in: area */
{
        return(area->size_and_free & ~MEM_AREA_FREE);
}

Here is the caller graph for this function:

UNIV_INLINE void mem_area_set_free	(	mem_area_t *	area,
		ibool	free
	)

Definition at line 170 of file mem0pool.c.

References MEM_AREA_FREE, and mem_area_struct::size_and_free.

Referenced by mem_area_alloc(), mem_area_free(), mem_pool_create(), and mem_pool_fill_free_list().

                                     : area */
        ibool           free)   /* in: free bit value */
{
#if TRUE != MEM_AREA_FREE
# error "TRUE != MEM_AREA_FREE"
#endif
        area->size_and_free = (area->size_and_free & ~MEM_AREA_FREE)
                                | free;
}

Here is the caller graph for this function:

UNIV_INLINE void mem_area_set_size	(	mem_area_t *	area,
		ulint	size
	)

Definition at line 142 of file mem0pool.c.

References MEM_AREA_FREE, and mem_area_struct::size_and_free.

Referenced by mem_area_free(), mem_pool_create(), and mem_pool_fill_free_list().

                                     : area */
        ulint           size)   /* in: size */
{
        area->size_and_free = (area->size_and_free & MEM_AREA_FREE)
                                | size;
}

Here is the caller graph for this function:

mem_pool_t* mem_pool_create

(

ulint

size

)

Definition at line 186 of file mem0pool.c.

References mem_pool_struct::buf, FALSE, mem_pool_struct::free_list, MEM_AREA_MIN_SIZE, mem_area_set_free(), mem_area_set_size(), mem_pool_struct::mutex, mutex_create, mem_pool_struct::reserved, mem_pool_struct::size, SYNC_MEM_POOL, TRUE, ut_2_exp(), ut_2_log(), ut_a, ut_ad, UT_LIST_ADD_FIRST, UT_LIST_INIT, ut_malloc(), and ut_malloc_low().

Referenced by mem_init().

                              : memory pool */
        ulint   size)   /* in: pool size in bytes */
{
        mem_pool_t*     pool;
        mem_area_t*     area;
        ulint           i;
        ulint           used;

        ut_a(size > 10000);

        pool = ut_malloc(sizeof(mem_pool_t));

        /* We do not set the memory to zero (FALSE) in the pool,
        but only when allocated at a higher level in mem0mem.c.
        This is to avoid masking useful Purify warnings. */

        pool->buf = ut_malloc_low(size, FALSE, TRUE);
        pool->size = size;

        mutex_create(&pool->mutex, SYNC_MEM_POOL);

        /* Initialize the free lists */

        for (i = 0; i < 64; i++) {

                UT_LIST_INIT(pool->free_list[i]);
        }

        used = 0;

        while (size - used >= MEM_AREA_MIN_SIZE) {

                i = ut_2_log(size - used);

                if (ut_2_exp(i) > size - used) {

                        /* ut_2_log rounds upward */

                        i--;
                }

                area = (mem_area_t*)(pool->buf + used);

                mem_area_set_size(area, ut_2_exp(i));
                mem_area_set_free(area, TRUE);

                UT_LIST_ADD_FIRST(free_list, pool->free_list[i], area);

                used = used + ut_2_exp(i);
        }

        ut_ad(size >= used);

        pool->reserved = 0;

        return(pool);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static ibool mem_pool_fill_free_list	(	ulint	i,
		mem_pool_t *	pool
	)			[static]

Definition at line 250 of file mem0pool.c.

References FALSE, mem_pool_struct::free_list, mem_analyze_corruption(), mem_area_set_free(), mem_area_set_size(), mem_pool_struct::mutex, NULL, TRUE, ut_2_exp(), ut_ad, ut_error, UT_LIST_ADD_FIRST, UT_LIST_GET_FIRST, UT_LIST_GET_LEN, UT_LIST_REMOVE, and ut_print_timestamp().

Referenced by mem_area_alloc().

                                      : TRUE if we were able to insert a
                                block to the free list */
        ulint           i,      /* in: free list index */
        mem_pool_t*     pool)   /* in: memory pool */
{
        mem_area_t*     area;
        mem_area_t*     area2;
        ibool           ret;

#ifdef UNIV_SYNC_DEBUG
        ut_ad(mutex_own(&(pool->mutex)));
#endif /* UNIV_SYNC_DEBUG */

        if (i >= 63) {
                /* We come here when we have run out of space in the
                memory pool: */

                return(FALSE);
        }

        area = UT_LIST_GET_FIRST(pool->free_list[i + 1]);

        if (area == NULL) {
                if (UT_LIST_GET_LEN(pool->free_list[i + 1]) > 0) {
                        ut_print_timestamp(stderr);

                        fprintf(stderr,
"  InnoDB: Error: mem pool free list %lu length is %lu\n"
"InnoDB: though the list is empty!\n",
                        (ulong) i + 1,
                        (ulong) UT_LIST_GET_LEN(pool->free_list[i + 1]));
                }

                ret = mem_pool_fill_free_list(i + 1, pool);

                if (ret == FALSE) {

                        return(FALSE);
                }

                area = UT_LIST_GET_FIRST(pool->free_list[i + 1]);
        }

        if (UT_LIST_GET_LEN(pool->free_list[i + 1]) == 0) {
                mem_analyze_corruption(area);

                ut_error;
        }

        UT_LIST_REMOVE(free_list, pool->free_list[i + 1], area);

        area2 = (mem_area_t*)(((byte*)area) + ut_2_exp(i));

        mem_area_set_size(area2, ut_2_exp(i));
        mem_area_set_free(area2, TRUE);

        UT_LIST_ADD_FIRST(free_list, pool->free_list[i], area2);

        mem_area_set_size(area, ut_2_exp(i));

        UT_LIST_ADD_FIRST(free_list, pool->free_list[i], area);

        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ulint mem_pool_get_reserved

(

mem_pool_t *

pool

)

Definition at line 645 of file mem0pool.c.

References mem_pool_struct::mutex, mutex_enter, mutex_exit(), and mem_pool_struct::reserved.

Referenced by srv_printf_innodb_monitor().

                                      : reserved memory in bytes */
        mem_pool_t*     pool)   /* in: memory pool */
{
        ulint   reserved;

        mutex_enter(&(pool->mutex));

        reserved = pool->reserved;

        mutex_exit(&(pool->mutex));

        return(reserved);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mem_pool_mutex_enter

(

void

)

Definition at line 110 of file mem0pool.c.

References mem_comm_pool, mem_pool_struct::mutex, and mutex_enter.

Referenced by mem_heap_block_free(), and mem_heap_create_block().

{
        mutex_enter(&(mem_comm_pool->mutex));
}

Here is the caller graph for this function:

void mem_pool_mutex_exit

(

void

)

Definition at line 120 of file mem0pool.c.

References mem_comm_pool, mem_pool_struct::mutex, and mutex_exit().

Referenced by mem_heap_block_free(), and mem_heap_create_block().

{
        mutex_exit(&(mem_comm_pool->mutex));
}

Here is the call graph for this function:

Here is the caller graph for this function:

void mem_pool_print_info	(	FILE *	outfile,
		mem_pool_t *	pool
	)

Definition at line 613 of file mem0pool.c.

References mem_pool_struct::free_list, mem_pool_validate(), mem_pool_struct::mutex, mutex_enter, ut_2_exp(), and UT_LIST_GET_LEN.

Referenced by mem_print_info_low().

                                     : output file to write to */
        mem_pool_t*     pool)   /* in: memory pool */
{
        ulint           i;

        mem_pool_validate(pool);

        fprintf(outfile, "INFO OF A MEMORY POOL\n");

        mutex_enter(&(pool->mutex));

        for (i = 0; i < 64; i++) {
                if (UT_LIST_GET_LEN(pool->free_list[i]) > 0) {

                        fprintf(outfile,
                          "Free list length %lu for blocks of size %lu\n",
                          (ulong) UT_LIST_GET_LEN(pool->free_list[i]),
                          (ulong) ut_2_exp(i));
                }
        }

        fprintf(outfile, "Pool size %lu, reserved %lu.\n", (ulong) pool->size,
                (ulong) pool->reserved);
        mutex_exit(&(pool->mutex));
}

Here is the call graph for this function:

Here is the caller graph for this function:

ibool mem_pool_validate

(

mem_pool_t *

pool

)

Definition at line 567 of file mem0pool.c.

References free, mem_pool_struct::free_list, mem_area_get_buddy(), mem_area_get_free(), mem_area_get_size(), mem_pool_struct::mutex, mutex_enter, mutex_exit(), NULL, mem_pool_struct::reserved, mem_pool_struct::size, TRUE, ut_2_exp(), ut_a, UT_LIST_GET_FIRST, UT_LIST_GET_NEXT, and UT_LIST_VALIDATE.

Referenced by mem_area_alloc(), mem_area_free(), and mem_pool_print_info().

                                      : TRUE if ok */
        mem_pool_t*     pool)   /* in: memory pool */
{
        mem_area_t*     area;
        mem_area_t*     buddy;
        ulint           free;
        ulint           i;

        mutex_enter(&(pool->mutex));

        free = 0;

        for (i = 0; i < 64; i++) {

                UT_LIST_VALIDATE(free_list, mem_area_t, pool->free_list[i]);

                area = UT_LIST_GET_FIRST(pool->free_list[i]);

                while (area != NULL) {
                        ut_a(mem_area_get_free(area));
                        ut_a(mem_area_get_size(area) == ut_2_exp(i));

                        buddy = mem_area_get_buddy(area, ut_2_exp(i), pool);

                        ut_a(!buddy || !mem_area_get_free(buddy)
                                || (ut_2_exp(i) != mem_area_get_size(buddy)));

                        area = UT_LIST_GET_NEXT(free_list, area);

                        free += ut_2_exp(i);
                }
        }

        ut_a(free + pool->reserved == pool->size);

        mutex_exit(&(pool->mutex));

        return(TRUE);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

Variable Documentation

mem_pool_t* mem_comm_pool = NULL

Definition at line 98 of file mem0pool.c.

Referenced by mem_heap_block_free(), mem_heap_create_block(), mem_init(), mem_pool_mutex_enter(), mem_pool_mutex_exit(), mem_print_info_low(), and srv_printf_innodb_monitor().

ulint mem_n_threads_inside = 0

Definition at line 104 of file mem0pool.c.

Referenced by mem_area_alloc(), and mem_area_free().

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.