From 1c236fd5c734b7388d7625ce8c3d4b2d6da9fcfb Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Tue, 18 Oct 2005 15:01:19 +0000 Subject: [PATCH] Lots of clean-ups. Replace __inline__ with INLINE macro. Use the _mesa_calloc(), _mesa_free() functions. Clean-up formatting, doxygen-style comments. --- src/mesa/main/execmem.c | 57 ++++++++++++++++++++++++++++++++--- src/mesa/main/mm.c | 61 +++++++++++++++++++++---------------- src/mesa/main/mm.h | 66 ++++++++++++++++++++++++++++------------- 3 files changed, 134 insertions(+), 50 deletions(-) diff --git a/src/mesa/main/execmem.c b/src/mesa/main/execmem.c index 17ad06c90a4..89deaafad3a 100644 --- a/src/mesa/main/execmem.c +++ b/src/mesa/main/execmem.c @@ -1,3 +1,36 @@ +/* + * Mesa 3-D graphics library + * Version: 6.5 + * + * Copyright (C) 1999-2005 Brian Paul All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included + * in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL + * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN + * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + */ + + +/** + * \file exemem.c + * Functions for allocating executable memory. + * + * \author Keith Whitwell + */ + + #include "imports.h" #include "glthread.h" @@ -5,9 +38,15 @@ #ifdef __linux__ +/* + * Allocate a large block of memory which can hold code then dole it out + * in pieces by means of the generic memory manager code. +*/ + + #include #include -#include +#include "mm.h" #define EXEC_HEAP_SIZE (128*1024) @@ -16,7 +55,9 @@ _glthread_DECLARE_STATIC_MUTEX(exec_mutex); static memHeap_t *exec_heap = NULL; static unsigned char *exec_mem = NULL; -static void init_heap( void ) + +static void +init_heap(void) { if (!exec_heap) exec_heap = mmInit( 0, EXEC_HEAP_SIZE ); @@ -29,7 +70,7 @@ static void init_heap( void ) void * -_mesa_exec_malloc( GLuint size ) +_mesa_exec_malloc(GLuint size) { PMemBlock block = NULL; void *addr = NULL; @@ -50,6 +91,7 @@ _mesa_exec_malloc( GLuint size ) return addr; } + void _mesa_exec_free(void *addr) @@ -66,13 +108,19 @@ _mesa_exec_free(void *addr) _glthread_UNLOCK_MUTEX(exec_mutex); } + #else +/* + * Just use regular memory. + */ + void * -_mesa_exec_malloc( GLuint size ) +_mesa_exec_malloc(GLuint size) { return _mesa_malloc( size ); } + void _mesa_exec_free(void *addr) @@ -80,4 +128,5 @@ _mesa_exec_free(void *addr) _mesa_free(addr); } + #endif diff --git a/src/mesa/main/mm.c b/src/mesa/main/mm.c index 14563b2591c..e4c96821732 100644 --- a/src/mesa/main/mm.c +++ b/src/mesa/main/mm.c @@ -21,17 +21,14 @@ * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. * */ -/* $XFree86: xc/lib/GL/mesa/src/drv/common/mm.c,v 1.4 2002/10/30 12:51:27 alanh Exp $ */ - -#include -#include #include "mm.h" -void mmDumpMemInfo( memHeap_t *heap ) +void +mmDumpMemInfo(const memHeap_t *heap) { - TMemBlock *p; + const TMemBlock *p; fprintf(stderr, "Memory heap %p:\n", (void *)heap); if (heap == 0) { @@ -48,34 +45,37 @@ void mmDumpMemInfo( memHeap_t *heap ) fprintf(stderr, "End of memory blocks\n"); } -memHeap_t *mmInit(int ofs, - int size) +memHeap_t * +mmInit(int ofs, int size) { PMemBlock blocks; if (size <= 0) { return NULL; } - blocks = (TMemBlock *) calloc(1,sizeof(TMemBlock)); + blocks = (TMemBlock *) _mesa_calloc(sizeof(TMemBlock)); if (blocks) { blocks->ofs = ofs; blocks->size = size; blocks->free = 1; return (memHeap_t *)blocks; - } else + } + else { return NULL; + } } -static TMemBlock* SliceBlock(TMemBlock *p, - int startofs, int size, - int reserved, int alignment) +static TMemBlock * +SliceBlock(TMemBlock *p, + int startofs, int size, + int reserved, int alignment) { TMemBlock *newblock; /* break left */ if (startofs > p->ofs) { - newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock)); + newblock = (TMemBlock*) _mesa_calloc(sizeof(TMemBlock)); if (!newblock) return NULL; newblock->ofs = startofs; @@ -89,7 +89,7 @@ static TMemBlock* SliceBlock(TMemBlock *p, /* break right */ if (size < p->size) { - newblock = (TMemBlock*) calloc(1,sizeof(TMemBlock)); + newblock = (TMemBlock*) _mesa_calloc(sizeof(TMemBlock)); if (!newblock) return NULL; newblock->ofs = startofs + size; @@ -107,7 +107,9 @@ static TMemBlock* SliceBlock(TMemBlock *p, return p; } -PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch) + +PMemBlock +mmAllocMem(memHeap_t *heap, int size, int align2, int startSearch) { int mask,startofs,endofs; TMemBlock *p; @@ -136,7 +138,9 @@ PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, int startSearch) return p; } -PMemBlock mmFindBlock( memHeap_t *heap, int start) + +PMemBlock +mmFindBlock(memHeap_t *heap, int start) { TMemBlock *p = (TMemBlock *)heap; @@ -151,19 +155,22 @@ PMemBlock mmFindBlock( memHeap_t *heap, int start) } -static __inline__ int Join2Blocks(TMemBlock *p) +static INLINE int +Join2Blocks(TMemBlock *p) { + /* XXX there should be some assertions here */ if (p->free && p->next && p->next->free) { TMemBlock *q = p->next; p->size += q->size; p->next = q->next; - free(q); + _mesa_free(q); return 1; } return 0; } -int mmFreeMem(PMemBlock b) +int +mmFreeMem(PMemBlock b) { TMemBlock *p,*prev; @@ -196,16 +203,18 @@ int mmFreeMem(PMemBlock b) } -void mmDestroy(memHeap_t *heap) +void +mmDestroy(memHeap_t *heap) { - TMemBlock *p,*q; + TMemBlock *p; if (!heap) return; - p = (TMemBlock *)heap; + + p = (TMemBlock *) heap; while (p) { - q = p->next; - free(p); - p = q; + TMemBlock *next = p->next; + _mesa_free(p); + p = next; } } diff --git a/src/mesa/main/mm.h b/src/mesa/main/mm.h index 83a4ac8c74d..33c986b4c7d 100644 --- a/src/mesa/main/mm.h +++ b/src/mesa/main/mm.h @@ -19,11 +19,21 @@ * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - * */ -#ifndef MM_INC -#define MM_INC + +/** + * Memory manager code. Primarily used by device drivers to manage texture + * heaps, etc. + */ + + +#ifndef MM_H +#define MM_H + + +#include "imports.h" + struct mem_block_t { struct mem_block_t *next; @@ -33,25 +43,39 @@ struct mem_block_t { unsigned int free:1; unsigned int reserved:1; }; + typedef struct mem_block_t TMemBlock; + typedef struct mem_block_t *PMemBlock; /* a heap is just the first block in a chain */ typedef struct mem_block_t memHeap_t; -static __inline__ int mmBlockSize(PMemBlock b) -{ return b->size; } -static __inline__ int mmOffset(PMemBlock b) -{ return b->ofs; } +/* XXX are these needed? */ +#if 0 +static INLINE int +mmBlockSize(PMemBlock b) +{ + return b->size; +} -/* +static INLINE int +mmOffset(PMemBlock b) +{ + return b->ofs; +} +#endif + + + +/** * input: total size in bytes * return: a heap pointer if OK, NULL if error */ -memHeap_t *mmInit( int ofs, int size ); +extern memHeap_t *mmInit(int ofs, int size); -/* +/** * Allocate 'size' bytes with 2^align2 bytes alignment, * restrict the search to free memory after 'startSearch' * depth and back buffers should be in different 4mb banks @@ -61,29 +85,31 @@ memHeap_t *mmInit( int ofs, int size ); * startSearch = linear offset from start of heap to begin search * return: pointer to the allocated block, 0 if error */ -PMemBlock mmAllocMem( memHeap_t *heap, int size, int align2, - int startSearch ); +extern PMemBlock mmAllocMem(memHeap_t *heap, int size, int align2, + int startSearch); -/* +/** * Free block starts at offset * input: pointer to a block * return: 0 if OK, -1 if error */ -int mmFreeMem( PMemBlock b ); +extern int mmFreeMem(PMemBlock b); -/* +/** * Free block starts at offset * input: pointer to a heap, start offset * return: pointer to a block */ -PMemBlock mmFindBlock( memHeap_t *heap, int start); +extern PMemBlock mmFindBlock(memHeap_t *heap, int start); -/* +/** * destroy MM */ -void mmDestroy( memHeap_t *mmInit ); +extern void mmDestroy(memHeap_t *mmInit); -/* For debuging purpose. */ -void mmDumpMemInfo( memHeap_t *mmInit ); +/** + * For debuging purpose. + */ +extern void mmDumpMemInfo(const memHeap_t *mmInit); #endif -- 2.30.2