mirror of
https://github.com/autc04/Retro68.git
synced 2024-09-07 13:54:33 +00:00
206 lines
6.2 KiB
C
206 lines
6.2 KiB
C
|
/* frame_malloc.h -*-C++-*-
|
||
|
*
|
||
|
*************************************************************************
|
||
|
*
|
||
|
* @copyright
|
||
|
* Copyright (C) 2009-2013, Intel Corporation
|
||
|
* All rights reserved.
|
||
|
*
|
||
|
* @copyright
|
||
|
* Redistribution and use in source and binary forms, with or without
|
||
|
* modification, are permitted provided that the following conditions
|
||
|
* are met:
|
||
|
*
|
||
|
* * Redistributions of source code must retain the above copyright
|
||
|
* notice, this list of conditions and the following disclaimer.
|
||
|
* * Redistributions in binary form must reproduce the above copyright
|
||
|
* notice, this list of conditions and the following disclaimer in
|
||
|
* the documentation and/or other materials provided with the
|
||
|
* distribution.
|
||
|
* * Neither the name of Intel Corporation nor the names of its
|
||
|
* contributors may be used to endorse or promote products derived
|
||
|
* from this software without specific prior written permission.
|
||
|
*
|
||
|
* @copyright
|
||
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
||
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
||
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
||
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
||
|
* HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
|
||
|
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
|
||
|
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
|
||
|
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
|
||
|
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
|
||
|
* WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||
|
* POSSIBILITY OF SUCH DAMAGE.
|
||
|
**************************************************************************/
|
||
|
|
||
|
/**
|
||
|
* @file frame_malloc.h
|
||
|
*
|
||
|
* @brief The frame allocation routines manage memory in a per-worker pool.
|
||
|
*
|
||
|
* The name "frame malloc" refers to an earlier implementation of Cilk which
|
||
|
* allocated frames from the heap using this allocator.
|
||
|
*/
|
||
|
|
||
|
#ifndef INCLUDED_FRAME_MALLOC_DOT_H
|
||
|
#define INCLUDED_FRAME_MALLOC_DOT_H
|
||
|
|
||
|
#include "worker_mutex.h"
|
||
|
#include "rts-common.h"
|
||
|
#include <internal/abi.h> // __cilkrts_worker
|
||
|
|
||
|
#ifdef __cplusplus
|
||
|
# include <cstddef>
|
||
|
#else
|
||
|
# include <stddef.h>
|
||
|
#endif
|
||
|
|
||
|
__CILKRTS_BEGIN_EXTERN_C
|
||
|
|
||
|
/**
|
||
|
* Number of buckets. Gives us buckets to hold 64, 128, 256, 512, 1024
|
||
|
* and 2048 bytes
|
||
|
*/
|
||
|
#define FRAME_MALLOC_NBUCKETS 6
|
||
|
|
||
|
/** Layout of frames when unallocated */
|
||
|
struct free_list {
|
||
|
/** Pointer to next free frame */
|
||
|
struct free_list *cdr;
|
||
|
};
|
||
|
|
||
|
/** per-worker memory cache */
|
||
|
struct __cilkrts_frame_cache
|
||
|
{
|
||
|
/** Mutex to serialize access */
|
||
|
struct mutex lock;
|
||
|
|
||
|
/** Linked list of frames */
|
||
|
struct pool_cons *pool_list;
|
||
|
|
||
|
/** Low bound of memory in pool */
|
||
|
char *pool_begin;
|
||
|
|
||
|
/** High bound of memory in pool */
|
||
|
char *pool_end;
|
||
|
|
||
|
/** Global free-list buckets */
|
||
|
struct free_list *global_free_list[FRAME_MALLOC_NBUCKETS];
|
||
|
|
||
|
/**
|
||
|
* How many bytes to obtain at once from the global pool
|
||
|
* (approximately)
|
||
|
*/
|
||
|
size_t batch_size;
|
||
|
|
||
|
/** Garbage-collect a bucket when its potential exceeds the limit */
|
||
|
size_t potential_limit;
|
||
|
|
||
|
/** If TRUE, check for memory leaks at the end of execution */
|
||
|
int check_for_leaks;
|
||
|
|
||
|
/** Bytes of memory allocated from the OS by the global cache */
|
||
|
size_t allocated_from_os;
|
||
|
|
||
|
/** Tracks memory allocated by a chunk that isn't a full bucket size */
|
||
|
size_t wasted;
|
||
|
|
||
|
/** Bytes of memory allocated from the global cache */
|
||
|
size_t allocated_from_global_pool;
|
||
|
};
|
||
|
|
||
|
/**
|
||
|
* Allocate memory from the per-worker pool. If the size is too large, or
|
||
|
* if we're given a NULL worker, the memory is allocated using
|
||
|
* __cilkrts_malloc().
|
||
|
*
|
||
|
* @param w The worker to allocate the memory from.
|
||
|
* @param size The number of bytes to allocate.
|
||
|
*
|
||
|
* @return pointer to allocated memory block.
|
||
|
*/
|
||
|
COMMON_PORTABLE
|
||
|
void *__cilkrts_frame_malloc(__cilkrts_worker *w,
|
||
|
size_t size) cilk_nothrow;
|
||
|
|
||
|
/**
|
||
|
* Return memory to the per-worker pool. If the size is too large, or
|
||
|
* if we're given a NULL worker, the memory is freed using
|
||
|
* __cilkrts_free().
|
||
|
*
|
||
|
* @param w The worker to allocate the memory from.
|
||
|
* @param p The memory block to be released.
|
||
|
* @param size The size of the block, in bytes.
|
||
|
*/
|
||
|
COMMON_PORTABLE
|
||
|
void __cilkrts_frame_free(__cilkrts_worker *w,
|
||
|
void* p,
|
||
|
size_t size) cilk_nothrow;
|
||
|
|
||
|
/**
|
||
|
* Destroy the global cache stored in the global state, freeing all memory
|
||
|
* to the global heap. Checks whether any memory has been allocated but
|
||
|
* not freed.
|
||
|
*
|
||
|
* @param g The global state.
|
||
|
*/
|
||
|
COMMON_PORTABLE
|
||
|
void __cilkrts_frame_malloc_global_cleanup(global_state_t *g);
|
||
|
|
||
|
/**
|
||
|
* Initialize a worker's memory cache. Initially it is empty.
|
||
|
*
|
||
|
* @param w The worker who's memory cache is to be initialized.
|
||
|
*/
|
||
|
COMMON_PORTABLE
|
||
|
void __cilkrts_frame_malloc_per_worker_init(__cilkrts_worker *w);
|
||
|
|
||
|
/**
|
||
|
* If check_for_leaks is set in the global state's memory cache, free any
|
||
|
* memory in the worker's memory cache.
|
||
|
*
|
||
|
* If check_for_leask is not set, nothing happens.
|
||
|
*
|
||
|
* @param w The worker who's memory cache is to be cleaned up.
|
||
|
*/
|
||
|
COMMON_PORTABLE
|
||
|
void __cilkrts_frame_malloc_per_worker_cleanup(__cilkrts_worker *w);
|
||
|
|
||
|
/**
|
||
|
* Round a number of bytes to the size of the smallest bucket that will
|
||
|
* hold it. If the size is bigger than the largest bucket, the value is
|
||
|
* unchanged.
|
||
|
*
|
||
|
* @param size Number of bytes to be rounded up to the nearest bucket size.
|
||
|
*
|
||
|
* @return The size of the smallest bucket that will hold the specified bytes.
|
||
|
*/
|
||
|
COMMON_PORTABLE
|
||
|
size_t __cilkrts_frame_malloc_roundup(size_t size) cilk_nothrow;
|
||
|
|
||
|
/**
|
||
|
* Return the number of bytes that can fit into a bucket.
|
||
|
*
|
||
|
* Preconditions:
|
||
|
* - The index must be in the range 0 - FRAME_MALLOC_NBUCKETS
|
||
|
*
|
||
|
* @param bucket Index of the bucket to be sized.
|
||
|
*/
|
||
|
COMMON_PORTABLE
|
||
|
size_t __cilkrts_size_of_bucket(int bucket) cilk_nothrow;
|
||
|
|
||
|
/**
|
||
|
* Initialize the global memory cache.
|
||
|
*
|
||
|
* @param g The global state.
|
||
|
*/
|
||
|
COMMON_PORTABLE
|
||
|
void __cilkrts_frame_malloc_global_init(global_state_t *g);
|
||
|
|
||
|
__CILKRTS_END_EXTERN_C
|
||
|
|
||
|
#endif // ! defined(INCLUDED_FRAME_MALLOC_DOT_H)
|