+/*
+ * 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"
#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 <unistd.h>
#include <sys/mman.h>
-#include <mm.h>
+#include "mm.h"
#define EXEC_HEAP_SIZE (128*1024)
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 );
void *
-_mesa_exec_malloc( GLuint size )
+_mesa_exec_malloc(GLuint size)
{
PMemBlock block = NULL;
void *addr = NULL;
return addr;
}
+
void
_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)
_mesa_free(addr);
}
+
#endif
* 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 <stdlib.h>
-#include <stdio.h>
#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) {
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;
/* 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;
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;
return p;
}
-PMemBlock mmFindBlock( memHeap_t *heap, int start)
+
+PMemBlock
+mmFindBlock(memHeap_t *heap, int start)
{
TMemBlock *p = (TMemBlock *)heap;
}
-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;
}
-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;
}
}
* 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;
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
* 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
projects / mesa.git / commitdiff