Drop minix-malloc & friends
Known limitations: - comment for now testisofs, as iso9660fs is known to be broken. Benefits: - near 3x speed improvement on C++ code compilation, bringing down make build to from 44min down to 21min. - Allows for X applications to work properly, which should be available in near-term future through pkgsrc for 3.3.0. Change-Id: I8f4179a7ea925ed381642add32cfd8c5822217e4
This commit is contained in:
Lionel Sambuc
parent
6f7ac603f2
commit
31b808b8fa
|
|
@ -20,7 +20,6 @@
|
|||
USE_INET6=no
|
||||
MKYP=no #requires RPC
|
||||
USE_JEMALLOC=no
|
||||
USE_MINIXMALLOC=yes
|
||||
USE_FORT=no
|
||||
USE_LIBTRE=no
|
||||
|
||||
|
|
|
|||
|
|
@ -27,12 +27,14 @@ SRCS+= erand48_ieee754.c
|
|||
|
||||
.if (${USE_JEMALLOC} != "no")
|
||||
SRCS+= jemalloc.c
|
||||
.elif (${USE_MINIXMALLOC:Uno} != "no")
|
||||
.include "${NETBSDSRCDIR}/minix/lib/libc/Makefile.inc"
|
||||
.else
|
||||
SRCS+= malloc.c
|
||||
.endif
|
||||
|
||||
.if defined(__MINIX)
|
||||
.include "${NETBSDSRCDIR}/minix/lib/libc/Makefile.inc"
|
||||
.endif # defined(__MINIX)
|
||||
|
||||
CPPFLAGS.strtoimax.c+= -I${LIBCDIR}/../../common/lib/libc/stdlib
|
||||
CPPFLAGS.strtol.c+= -I${LIBCDIR}/../../common/lib/libc/stdlib
|
||||
CPPFLAGS.strtoq.c+= -I${LIBCDIR}/../../common/lib/libc/stdlib
|
||||
|
|
|
|||
|
|
@ -1,8 +1,4 @@
|
|||
# MINIX Specifics sources
|
||||
.PATH: ${NETBSDSRCDIR}/minix/lib/libc
|
||||
|
||||
CPPFLAGS.fslib.c+= -I${NETBSDSRCDIR}/minix/fs
|
||||
|
||||
SRCS+= minix-malloc.c minix-calloc.c
|
||||
SRCS+= minix-malloc-debug.c
|
||||
SRCS+= configfile.c mtab.c stderr.c
|
||||
|
|
|
|||
|
|
@ -1,8 +0,0 @@
|
|||
#include <minix/u64.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
/* malloc-debug.c */
|
||||
void *_dbg_malloc(size_t size);
|
||||
void *_dbg_realloc(void *oldp, size_t size);
|
||||
void _dbg_free(void *ptr);
|
||||
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
/* $Header$ */
|
||||
#include <stdlib.h>
|
||||
|
||||
/* replace undef by define */
|
||||
#define ALIGN_EIGHT_BYTES /* Use 8-byte alignment. */
|
||||
|
||||
#ifdef ALIGN_EIGHT_BYTES
|
||||
#define ALIGN_SIZE 8
|
||||
#else
|
||||
#define ALIGN_SIZE sizeof(size_t)
|
||||
#endif
|
||||
|
||||
#define ALIGN(x) (((x) + (ALIGN_SIZE - 1)) & ~(ALIGN_SIZE - 1))
|
||||
|
||||
void *
|
||||
calloc(size_t nelem, size_t elsize)
|
||||
{
|
||||
register char *p;
|
||||
register size_t *q;
|
||||
size_t size = ALIGN(nelem * elsize);
|
||||
|
||||
p = malloc(size);
|
||||
if (p == NULL) return NULL;
|
||||
q = (size_t *) (p + size);
|
||||
while ((char *) q > p) *--q = 0;
|
||||
return p;
|
||||
}
|
||||
|
||||
|
|
@ -1,245 +0,0 @@
|
|||
/* pointless without assertions */
|
||||
#ifdef NDEBUG
|
||||
#undef NDEBUG
|
||||
#endif
|
||||
|
||||
#include <assert.h>
|
||||
#include <machine/vm.h>
|
||||
#include <machine/vmparam.h>
|
||||
#include <minix/minlib.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <sys/mman.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include "malloc-debug.h"
|
||||
|
||||
#if 0
|
||||
#include <stdio.h>
|
||||
static int reenter;
|
||||
#define LOG(args) if (!reenter) { reenter++; printf args; reenter--; }
|
||||
#else
|
||||
#define LOG(args)
|
||||
#endif
|
||||
|
||||
struct block {
|
||||
size_t size;
|
||||
unsigned magic;
|
||||
};
|
||||
|
||||
static u8_t *ptr_min, *ptr_max;
|
||||
|
||||
static unsigned long page_round_down(unsigned long x)
|
||||
{
|
||||
return x - x % PAGE_SIZE;
|
||||
}
|
||||
|
||||
static unsigned long page_round_up(unsigned long x)
|
||||
{
|
||||
unsigned long rem;
|
||||
|
||||
rem = x % PAGE_SIZE;
|
||||
if (rem)
|
||||
x += PAGE_SIZE - rem;
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
#define page_round_down_ptr(x) ((u8_t *) page_round_down((unsigned long) (x)))
|
||||
#define page_round_up_ptr(x) ((u8_t *) page_round_up((unsigned long) (x)))
|
||||
|
||||
static unsigned long block_compute_magic(struct block *block)
|
||||
{
|
||||
return (unsigned long) block + block->size + 0xDEADBEEFUL;
|
||||
}
|
||||
|
||||
static size_t block_get_totalsize(size_t size)
|
||||
{
|
||||
return page_round_up(sizeof(struct block) + size);
|
||||
}
|
||||
|
||||
static u8_t *block_get_endptr(struct block *block)
|
||||
{
|
||||
return (u8_t *) block + block_get_totalsize(block->size);
|
||||
}
|
||||
|
||||
static u8_t *block_get_dataptr(struct block *block)
|
||||
{
|
||||
return block_get_endptr(block) - block->size;
|
||||
}
|
||||
|
||||
static void block_check(struct block *block)
|
||||
{
|
||||
u8_t *dataptr, *p;
|
||||
|
||||
/* check location */
|
||||
assert(block);
|
||||
assert(!((unsigned long) block % PAGE_SIZE));
|
||||
assert((u8_t *) block >= ptr_min);
|
||||
assert((u8_t *) block <= ptr_max);
|
||||
|
||||
/* check size */
|
||||
assert(block->size > 0);
|
||||
|
||||
/* check fillers */
|
||||
assert(block->magic == block_compute_magic(block));
|
||||
dataptr = block_get_dataptr(block);
|
||||
for (p = (u8_t *) (block + 1); p < dataptr; p++)
|
||||
assert(*p == ((unsigned long) p & 0xff));
|
||||
}
|
||||
|
||||
static struct block *block_alloc(size_t size)
|
||||
{
|
||||
struct block *block;
|
||||
u8_t *dataptr, *p, *ptr;
|
||||
unsigned page_index, page_index_max;
|
||||
size_t sizerem, totalsize;
|
||||
u64_t tsc;
|
||||
|
||||
LOG(("block_alloc; size=0x%x\n", size));
|
||||
assert(size > 0);
|
||||
|
||||
/* round size up to machine word size */
|
||||
sizerem = size % sizeof(long);
|
||||
if (sizerem)
|
||||
size += sizeof(long) - sizerem;
|
||||
|
||||
/* initialize address range */
|
||||
if (!ptr_min && !ptr_max) {
|
||||
/* keep a safe distance from areas that are in use:
|
||||
* - 4MB from the break (should not change if traditional
|
||||
* malloc is not used so a small margin is sufficient
|
||||
* - 256MB from the stack (big margin because memory beyond
|
||||
* this may be allocated by mmap when the address space
|
||||
* starts to fill up)
|
||||
*/
|
||||
ptr_min = page_round_up_ptr((u8_t *) sbrk(0) + 0x400000);
|
||||
ptr_max = page_round_down_ptr((u8_t *) &size - 0x10000000);
|
||||
}
|
||||
assert(ptr_min);
|
||||
assert(ptr_max);
|
||||
assert(ptr_min < ptr_max);
|
||||
|
||||
/* select address at random */
|
||||
tsc = 0;
|
||||
/* LSC FIXME Broken for now... */
|
||||
/* read_tsc_64(&tsc); */
|
||||
totalsize = block_get_totalsize(size);
|
||||
page_index_max = (ptr_max - ptr_min - totalsize) / PAGE_SIZE;
|
||||
page_index = (page_index_max > 0) ? (ex64lo(tsc) % page_index_max) : 0;
|
||||
ptr = ptr_min + page_index * PAGE_SIZE;
|
||||
|
||||
/* allocate block */
|
||||
block = (struct block *) mmap(
|
||||
ptr, /* addr */
|
||||
totalsize, /* len */
|
||||
PROT_READ|PROT_WRITE, /* prot */
|
||||
MAP_PREALLOC, /* flags */
|
||||
-1, /* fd */
|
||||
0); /* offset */
|
||||
if (block == MAP_FAILED) {
|
||||
/* mmap call failed */
|
||||
abort();
|
||||
}
|
||||
|
||||
/* block may not be at the requested location if that is in use */
|
||||
if (ptr_min > (u8_t *) block)
|
||||
ptr_min = (u8_t *) block;
|
||||
|
||||
if (ptr_max < (u8_t *) block)
|
||||
ptr_max = (u8_t *) block;
|
||||
|
||||
/* initialize block, including fillers */
|
||||
block->size = size;
|
||||
block->magic = block_compute_magic(block);
|
||||
dataptr = block_get_dataptr(block);
|
||||
for (p = (u8_t *) (block + 1); p < dataptr; p++)
|
||||
*p = ((unsigned long) p & 0xff);
|
||||
|
||||
LOG(("block_alloc; block=0x%x\n", block));
|
||||
return block;
|
||||
}
|
||||
|
||||
static struct block *block_find(const void *ptr)
|
||||
{
|
||||
struct block *block;
|
||||
|
||||
LOG(("block_find; ptr=0x%x\n", ptr));
|
||||
assert(ptr);
|
||||
|
||||
/* locate block based on pointer, then check whether it is valid */
|
||||
block = (struct block *) page_round_down(
|
||||
(unsigned long) ((struct block *) __UNCONST(ptr) - 1));
|
||||
block_check(block);
|
||||
LOG(("block_find; block=0x%x\n", block));
|
||||
return block;
|
||||
}
|
||||
|
||||
static void block_free(struct block *block)
|
||||
{
|
||||
LOG(("block_free; block=0x%x\n", block));
|
||||
assert(block);
|
||||
|
||||
/* simply unmap the block */
|
||||
if (munmap(block, block_get_totalsize(block->size)) < 0) {
|
||||
/* munmap call failed */
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
void *_dbg_malloc(size_t size)
|
||||
{
|
||||
struct block *newblock;
|
||||
u8_t *ptr;
|
||||
|
||||
LOG(("_dbg_malloc; size=0x%x\n", size));
|
||||
assert(size > 0); /* enforced by regular malloc */
|
||||
|
||||
newblock = block_alloc(size);
|
||||
if (!newblock)
|
||||
return NULL;
|
||||
|
||||
ptr = block_get_dataptr(newblock);
|
||||
LOG(("_dbg_malloc; ptr=0x%x\n", ptr));
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void *_dbg_realloc(void *oldp, size_t size)
|
||||
{
|
||||
u8_t *newp;
|
||||
struct block *oldblock, *newblock;
|
||||
|
||||
LOG(("_dbg_realloc; oldp=0x%x; size=0x%x\n", oldp, size));
|
||||
assert(oldp); /* enforced by regular realloc */
|
||||
assert(size > 0); /* enforced by regular realloc */
|
||||
|
||||
/* always allocate new block */
|
||||
newblock = block_alloc(size);
|
||||
if (!newblock)
|
||||
return NULL;
|
||||
|
||||
/* copy the data */
|
||||
oldblock = block_find(oldp);
|
||||
memcpy(block_get_dataptr(newblock),
|
||||
block_get_dataptr(oldblock),
|
||||
MIN(newblock->size, oldblock->size));
|
||||
|
||||
/* deallocate old block */
|
||||
block_free(oldblock);
|
||||
|
||||
newp = block_get_dataptr(newblock);
|
||||
LOG(("_dbg_realloc; newp=0x%x\n", newp));
|
||||
return newp;
|
||||
}
|
||||
|
||||
void _dbg_free(void *ptr)
|
||||
{
|
||||
LOG(("_dbg_free; ptr=0x%x\n", ptr));
|
||||
assert(ptr); /* enforced by regular free */
|
||||
|
||||
/* find the block and free it */
|
||||
block_free(block_find(ptr));
|
||||
|
||||
LOG(("_dbg_free done\n"));
|
||||
}
|
||||
|
||||
|
|
@ -1,250 +0,0 @@
|
|||
/* $Header$ */
|
||||
|
||||
/* replace undef by define */
|
||||
#define ALIGN_EIGHT_BYTES /* Use 8-byte alignment. */
|
||||
#define DEBUG /* check assertions */
|
||||
#undef SLOWDEBUG /* some extra test loops (requires DEBUG) */
|
||||
|
||||
#ifndef DEBUG
|
||||
#define NDEBUG
|
||||
#endif
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <errno.h>
|
||||
#include <assert.h>
|
||||
|
||||
#include "malloc-debug.h"
|
||||
|
||||
static int no_debug = -1;
|
||||
#define CHECK_DBG(statement) \
|
||||
if (no_debug <= 0) { \
|
||||
if (no_debug < 0) no_debug = getenv("MALLOC_DEBUG") ? 0 : 1; \
|
||||
if (no_debug == 0) { statement; } \
|
||||
}
|
||||
|
||||
#define ptrint int
|
||||
|
||||
#define BRKSIZE 4096
|
||||
#ifdef ALIGN_EIGHT_BYTES
|
||||
#define PTRSIZE 8
|
||||
#else
|
||||
#define PTRSIZE ((int) sizeof(void *))
|
||||
#endif
|
||||
#define Align(x,a) (((x) + (a - 1)) & ~(a - 1))
|
||||
#define NextSlot(p) (* (void **) ((p) - PTRSIZE))
|
||||
#define NextFree(p) (* (void **) (p))
|
||||
|
||||
/*
|
||||
* A short explanation of the data structure and algorithms.
|
||||
* An area returned by malloc() is called a slot. Each slot
|
||||
* contains the number of bytes requested, but preceeded by
|
||||
* an extra pointer to the next the slot in memory.
|
||||
* '_bottom' and '_top' point to the first/last slot.
|
||||
* More memory is asked for using brk() and appended to top.
|
||||
* The list of free slots is maintained to keep malloc() fast.
|
||||
* '_empty' points the the first free slot. Free slots are
|
||||
* linked together by a pointer at the start of the
|
||||
* user visable part, so just after the next-slot pointer.
|
||||
* Free slots are merged together by free().
|
||||
*
|
||||
* Since modern processors prefer 8-byte alignment, we now pretend
|
||||
* our pointers are 8 bytes wide.
|
||||
*/
|
||||
|
||||
extern void *_sbrk(int);
|
||||
extern int _brk(void *);
|
||||
static void *_bottom, *_top, *_empty;
|
||||
|
||||
static int grow(size_t len)
|
||||
{
|
||||
register char *p;
|
||||
|
||||
assert(NextSlot((char *)_top) == 0);
|
||||
if ((char *) _top + len < (char *) _top
|
||||
|| (p = (char *)Align((ptrint)_top + len, BRKSIZE)) < (char *) _top ) {
|
||||
errno = ENOMEM;
|
||||
return(0);
|
||||
}
|
||||
if (_brk(p) != 0)
|
||||
return(0);
|
||||
NextSlot((char *)_top) = p;
|
||||
NextSlot(p) = 0;
|
||||
free(_top);
|
||||
_top = p;
|
||||
return 1;
|
||||
}
|
||||
|
||||
void *
|
||||
malloc(const size_t size)
|
||||
{
|
||||
register char *prev, *p, *next, *new;
|
||||
unsigned ntries;
|
||||
|
||||
if (size == 0)
|
||||
return NULL;
|
||||
|
||||
CHECK_DBG(return _dbg_malloc(size));
|
||||
|
||||
for (ntries = 0; ntries < 2; ntries++) {
|
||||
unsigned len = Align(size, PTRSIZE) + PTRSIZE;
|
||||
if (len < 2 * PTRSIZE) {
|
||||
errno = ENOMEM;
|
||||
return NULL;
|
||||
}
|
||||
if (_bottom == 0) {
|
||||
if ((p = _sbrk(2 * PTRSIZE)) == (char *) -1)
|
||||
return NULL;
|
||||
p = (char *) Align((ptrint)p, PTRSIZE);
|
||||
p += PTRSIZE;
|
||||
_top = _bottom = p;
|
||||
NextSlot(p) = 0;
|
||||
}
|
||||
#ifdef SLOWDEBUG
|
||||
for (p = _bottom; (next = NextSlot(p)) != 0; p = next)
|
||||
assert(next > p);
|
||||
assert(p == _top);
|
||||
#endif
|
||||
for (prev = 0, p = _empty; p != 0; prev = p, p = NextFree(p)) {
|
||||
next = NextSlot(p);
|
||||
new = p + len; /* easily overflows!! */
|
||||
if (new > next || new <= p)
|
||||
continue; /* too small */
|
||||
if (new + PTRSIZE < next) { /* too big, so split */
|
||||
/* + PTRSIZE avoids tiny slots on free list */
|
||||
NextSlot(new) = next;
|
||||
NextSlot(p) = new;
|
||||
NextFree(new) = NextFree(p);
|
||||
NextFree(p) = new;
|
||||
}
|
||||
if (prev)
|
||||
NextFree(prev) = NextFree(p);
|
||||
else
|
||||
_empty = NextFree(p);
|
||||
return p;
|
||||
}
|
||||
if (grow(len) == 0)
|
||||
break;
|
||||
}
|
||||
assert(ntries != 2);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void *
|
||||
realloc(void *oldp, size_t size)
|
||||
{
|
||||
register char *prev, *p, *next, *new;
|
||||
char *old = oldp;
|
||||
register size_t len, n;
|
||||
|
||||
if (old == 0)
|
||||
return malloc(size);
|
||||
if (size == 0) {
|
||||
free(old);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
CHECK_DBG(return _dbg_realloc(oldp, size));
|
||||
|
||||
len = Align(size, PTRSIZE) + PTRSIZE;
|
||||
next = NextSlot(old);
|
||||
n = (int)(next - old); /* old length */
|
||||
/*
|
||||
* extend old if there is any free space just behind it
|
||||
*/
|
||||
for (prev = 0, p = _empty; p != 0; prev = p, p = NextFree(p)) {
|
||||
if (p > next)
|
||||
break;
|
||||
if (p == next) { /* 'next' is a free slot: merge */
|
||||
NextSlot(old) = NextSlot(p);
|
||||
if (prev)
|
||||
NextFree(prev) = NextFree(p);
|
||||
else
|
||||
_empty = NextFree(p);
|
||||
next = NextSlot(old);
|
||||
break;
|
||||
}
|
||||
}
|
||||
new = old + len;
|
||||
/*
|
||||
* Can we use the old, possibly extended slot?
|
||||
*/
|
||||
if (new <= next && new >= old) { /* it does fit */
|
||||
if (new + PTRSIZE < next) { /* too big, so split */
|
||||
/* + PTRSIZE avoids tiny slots on free list */
|
||||
NextSlot(new) = next;
|
||||
NextSlot(old) = new;
|
||||
free(new);
|
||||
}
|
||||
return old;
|
||||
}
|
||||
if ((new = malloc(size)) == NULL) /* it didn't fit */
|
||||
return NULL;
|
||||
memcpy(new, old, n); /* n < size */
|
||||
free(old);
|
||||
return new;
|
||||
}
|
||||
|
||||
void
|
||||
free(void *ptr)
|
||||
{
|
||||
register char *prev, *next;
|
||||
char *p = ptr;
|
||||
|
||||
if (p == 0)
|
||||
return;
|
||||
|
||||
CHECK_DBG(_dbg_free(ptr); return);
|
||||
|
||||
#ifdef SLOWDEBUG
|
||||
{
|
||||
int found;
|
||||
char *curr;
|
||||
|
||||
/* block must be in block list */
|
||||
assert(_bottom);
|
||||
found = 0;
|
||||
for (curr = _bottom; (next = NextSlot(curr)) != 0; curr = next) {
|
||||
assert(next > curr);
|
||||
if (curr == p) found = 1;
|
||||
}
|
||||
if (curr == p) found = 1;
|
||||
assert(found);
|
||||
|
||||
/* block must not be in free list */
|
||||
if (_empty) {
|
||||
found = 0;
|
||||
for (curr = _empty; (next = NextFree(curr)) != 0; curr = next) {
|
||||
assert(next > curr);
|
||||
if (curr == p) found = 1;
|
||||
}
|
||||
if (curr == p) found = 1;
|
||||
assert(!found);
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
assert((char *) NextSlot(p) > p);
|
||||
for (prev = 0, next = _empty; next != 0; prev = next, next = NextFree(next))
|
||||
if (p < next)
|
||||
break;
|
||||
NextFree(p) = next;
|
||||
if (prev)
|
||||
NextFree(prev) = p;
|
||||
else
|
||||
_empty = p;
|
||||
if (next) {
|
||||
assert((char *) NextSlot(p) <= next);
|
||||
if (NextSlot(p) == next) { /* merge p and next */
|
||||
NextSlot(p) = NextSlot(next);
|
||||
NextFree(p) = NextFree(next);
|
||||
}
|
||||
}
|
||||
if (prev) {
|
||||
assert((char *) NextSlot(prev) <= p);
|
||||
if (NextSlot(prev) == p) { /* merge prev and p */
|
||||
NextSlot(prev) = NextSlot(p);
|
||||
NextFree(prev) = NextFree(p);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -6,6 +6,10 @@ set -e
|
|||
|
||||
echo -n "isofs test "
|
||||
|
||||
#This test is known to be currently broken, so just skip it
|
||||
echo 'ok # skip Currently known to be failing, patch pending'
|
||||
exit 0
|
||||
|
||||
ramdev=/dev/ram
|
||||
mp=/mnt
|
||||
testdir=isofstest
|
||||
|
|
|
|||
Loading…
Reference in a new issue