mirror of
https://git.rwth-aachen.de/acs/public/villas/node/
synced 2025-03-09 00:00:00 +01:00
cosmetic changes (indentions, whitesapces, naming)
This commit is contained in:
parent
b4ba09d9f1
commit
bb745ea048
2 changed files with 80 additions and 64 deletions
|
|
@ -73,7 +73,7 @@ void * memory_alloc_aligned(struct memtype *m, size_t len, size_t alignment);
|
|||
|
||||
int memory_free(struct memtype *m, void *ptr, size_t len);
|
||||
|
||||
struct memtype* memtype_managed_init(void *ptr, size_t len);
|
||||
struct memtype * memtype_managed_init(void *ptr, size_t len);
|
||||
|
||||
extern struct memtype memtype_heap;
|
||||
extern struct memtype memtype_hugepage;
|
||||
|
|
|
|||
142
lib/memory.c
142
lib/memory.c
|
|
@ -21,9 +21,9 @@ int memory_init()
|
|||
{
|
||||
#ifdef __linux__
|
||||
int nr = kernel_get_nr_hugepages();
|
||||
|
||||
|
||||
debug(DBG_MEM | 2, "System has %d reserved hugepages", nr);
|
||||
|
||||
|
||||
if (nr < DEFAULT_NR_HUGEPAGES)
|
||||
kernel_set_nr_hugepages(DEFAULT_NR_HUGEPAGES);
|
||||
#endif
|
||||
|
|
@ -33,7 +33,7 @@ int memory_init()
|
|||
void * memory_alloc(struct memtype *m, size_t len)
|
||||
{
|
||||
void *ptr = m->alloc(m, len, sizeof(void *));
|
||||
|
||||
|
||||
debug(DBG_MEM | 2, "Allocated %#zx bytes of %s memory: %p", len, m->name, ptr);
|
||||
|
||||
return ptr;
|
||||
|
|
@ -42,9 +42,9 @@ void * memory_alloc(struct memtype *m, size_t len)
|
|||
void * memory_alloc_aligned(struct memtype *m, size_t len, size_t alignment)
|
||||
{
|
||||
void *ptr = m->alloc(m, len, alignment);
|
||||
|
||||
|
||||
debug(DBG_MEM | 2, "Allocated %#zx bytes of %#zx-byte-aligned %s memory: %p", len, alignment, m->name, ptr);
|
||||
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
|
|
@ -58,19 +58,19 @@ static void * memory_heap_alloc(struct memtype *m, size_t len, size_t alignment)
|
|||
{
|
||||
void *ptr;
|
||||
int ret;
|
||||
|
||||
|
||||
if (alignment < sizeof(void *))
|
||||
alignment = sizeof(void *);
|
||||
|
||||
|
||||
ret = posix_memalign(&ptr, alignment, len);
|
||||
|
||||
|
||||
return ret ? NULL : ptr;
|
||||
}
|
||||
|
||||
int memory_heap_free(struct memtype *m, void *ptr, size_t len)
|
||||
{
|
||||
free(ptr);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -79,20 +79,20 @@ static void * memory_hugepage_alloc(struct memtype *m, size_t len, size_t alignm
|
|||
{
|
||||
int prot = PROT_READ | PROT_WRITE;
|
||||
int flags = MAP_PRIVATE | MAP_ANONYMOUS;
|
||||
|
||||
|
||||
#ifdef __MACH__
|
||||
flags |= VM_FLAGS_SUPERPAGE_SIZE_2MB;
|
||||
#elif defined(__linux__)
|
||||
flags |= MAP_HUGETLB | MAP_LOCKED;
|
||||
#endif
|
||||
|
||||
|
||||
void *ret = mmap(NULL, len, prot, flags, -1, 0);
|
||||
|
||||
|
||||
if (ret == MAP_FAILED) {
|
||||
info("Failed to allocate huge pages: Check https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
@ -105,27 +105,31 @@ static int memory_hugepage_free(struct memtype *m, void *ptr, size_t len)
|
|||
|
||||
void* memory_managed_alloc(struct memtype *m, size_t len, size_t alignment)
|
||||
{
|
||||
/* Simple first-fit allocation */
|
||||
struct memblock *first = (struct memblock*) m->_vd;
|
||||
/* Simple first-fit allocation */
|
||||
struct memblock *first = m->_vd;
|
||||
struct memblock *block;
|
||||
|
||||
for (block = first; block != NULL; block = block->next) {
|
||||
if (block->flags & MEMBLOCK_USED)
|
||||
continue;
|
||||
char* cptr = (char*) block + sizeof(struct memblock);
|
||||
|
||||
char* cptr = (char *) block + sizeof(struct memblock);
|
||||
size_t avail = block->len;
|
||||
uintptr_t uptr = (uintptr_t) cptr;
|
||||
/* check alignment first; leave a gap at start of block to assure
|
||||
|
||||
/* Check alignment first; leave a gap at start of block to assure
|
||||
* alignment if necessary */
|
||||
uintptr_t rem = uptr % alignment;
|
||||
uintptr_t gap = 0;
|
||||
if (rem != 0) {
|
||||
gap = alignment - rem;
|
||||
if (gap > avail)
|
||||
/* next aligned address isn't in this block anymore */
|
||||
continue;
|
||||
continue; /* Next aligned address isn't in this block anymore */
|
||||
|
||||
cptr += gap;
|
||||
avail -= gap;
|
||||
}
|
||||
|
||||
if (avail >= len) {
|
||||
if (gap > sizeof(struct memblock)) {
|
||||
/* The alignment gap is big enough to fit another block.
|
||||
|
|
@ -133,21 +137,23 @@ void* memory_managed_alloc(struct memtype *m, size_t len, size_t alignment)
|
|||
* position, so we just change its len and create a new block
|
||||
* descriptor for the actual block we're handling. */
|
||||
block->len = gap - sizeof(struct memblock);
|
||||
struct memblock *newblock = (struct memblock*) (cptr - sizeof(struct memblock));
|
||||
struct memblock *newblock = (struct memblock *) (cptr - sizeof(struct memblock));
|
||||
newblock->prev = block;
|
||||
newblock->next = block->next;
|
||||
block->next = newblock;
|
||||
newblock->flags = 0;
|
||||
newblock->len = len;
|
||||
block = newblock;
|
||||
} else {
|
||||
}
|
||||
else {
|
||||
/* The gap is too small to fit another block descriptor, so we
|
||||
* must account for the gap length in the block length. */
|
||||
block->len = len + gap;
|
||||
}
|
||||
|
||||
if (avail > len + sizeof(struct memblock)) {
|
||||
/* imperfect fit, so create another block for the remaining part */
|
||||
struct memblock *newblock = (struct memblock*) (cptr + len);
|
||||
/* Imperfect fit, so create another block for the remaining part */
|
||||
struct memblock *newblock = (struct memblock *) (cptr + len);
|
||||
newblock->prev = block;
|
||||
newblock->next = block->next;
|
||||
block->next = newblock;
|
||||
|
|
@ -155,17 +161,21 @@ void* memory_managed_alloc(struct memtype *m, size_t len, size_t alignment)
|
|||
newblock->next->prev = newblock;
|
||||
newblock->flags = 0;
|
||||
newblock->len = avail - len - sizeof(struct memblock);
|
||||
} else {
|
||||
/* if this block was larger than the requested length, but only
|
||||
}
|
||||
else {
|
||||
/* If this block was larger than the requested length, but only
|
||||
* by less than sizeof(struct memblock), we may have wasted
|
||||
* memory by previous assignments to block->len. */
|
||||
block->len = avail;
|
||||
}
|
||||
|
||||
block->flags |= MEMBLOCK_USED;
|
||||
return (void*) cptr;
|
||||
|
||||
return (void *) cptr;
|
||||
}
|
||||
}
|
||||
/* no suitable block found */
|
||||
|
||||
/* No suitable block found */
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
@ -173,64 +183,80 @@ int memory_managed_free(struct memtype *m, void *ptr, size_t len)
|
|||
{
|
||||
struct memblock *first = m->_vd;
|
||||
struct memblock *block;
|
||||
char* cptr = (char*) ptr;
|
||||
char *cptr = ptr;
|
||||
|
||||
for (block = first; block != NULL; block = block->next) {
|
||||
if (!(block->flags & MEMBLOCK_USED))
|
||||
continue;
|
||||
/* since we may waste some memory at the start of a block to ensure
|
||||
|
||||
/* Since we may waste some memory at the start of a block to ensure
|
||||
* alignment, ptr may not actually be the start of the block */
|
||||
if ((char*) block + sizeof(struct memblock) <= cptr &&
|
||||
cptr < (char*) block + sizeof(struct memblock) + block->len) {
|
||||
/* try to merge it with neighbouring free blocks */
|
||||
if ((char *) block + sizeof(struct memblock) <= cptr &&
|
||||
cptr < (char *) block + sizeof(struct memblock) + block->len) {
|
||||
/* Try to merge it with neighbouring free blocks */
|
||||
if (block->prev && !(block->prev->flags & MEMBLOCK_USED) &&
|
||||
block->next && !(block->next->flags & MEMBLOCK_USED)) {
|
||||
/* special case first: both previous and next block are unused */
|
||||
/* Special case first: both previous and next block are unused */
|
||||
block->prev->len += block->len + block->next->len + 2 * sizeof(struct memblock);
|
||||
block->prev->next = block->next->next;
|
||||
if (block->next->next)
|
||||
block->next->next->prev = block->prev;
|
||||
} else if (block->prev && !(block->prev->flags & MEMBLOCK_USED)) {
|
||||
}
|
||||
else if (block->prev && !(block->prev->flags & MEMBLOCK_USED)) {
|
||||
block->prev->len += block->len + sizeof(struct memblock);
|
||||
block->prev->next = block->next;
|
||||
if (block->next)
|
||||
block->next->prev = block->prev;
|
||||
} else if (block->next && !(block->next->flags & MEMBLOCK_USED)) {
|
||||
}
|
||||
else if (block->next && !(block->next->flags & MEMBLOCK_USED)) {
|
||||
block->len += block->next->len + sizeof(struct memblock);
|
||||
block->next = block->next->next;
|
||||
if (block->next)
|
||||
block->next->prev = block;
|
||||
} else {
|
||||
/* no neighbouring free block, so just mark it as free */
|
||||
block->flags &= (~MEMBLOCK_USED);
|
||||
}
|
||||
else {
|
||||
/* no neighbouring free block, so just mark it as free */
|
||||
block->flags &= ~MEMBLOCK_USED;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
struct memtype* memtype_managed_init(void *ptr, size_t len)
|
||||
struct memtype * memtype_managed_init(void *ptr, size_t len)
|
||||
{
|
||||
struct memtype *mt = ptr;
|
||||
struct memblock *mb;
|
||||
char *cptr = ptr;
|
||||
|
||||
if (len < sizeof(struct memtype) + sizeof(struct memblock)) {
|
||||
info("memtype_managed_init: passed region too small");
|
||||
return NULL;
|
||||
}
|
||||
struct memtype *mt = (struct memtype*) ptr;
|
||||
mt->name = "managed";
|
||||
|
||||
/* Initialize memtype */
|
||||
mt->name = "managed";
|
||||
mt->flags = 0;
|
||||
mt->alloc = memory_managed_alloc;
|
||||
mt->free = memory_managed_free;
|
||||
mt->free = memory_managed_free;
|
||||
mt->alignment = 1;
|
||||
|
||||
char *cptr = (char*) ptr;
|
||||
cptr += ALIGN(sizeof(struct memtype), sizeof(void*));
|
||||
struct memblock *first = (struct memblock*) ((void*) cptr);
|
||||
first->prev = NULL;
|
||||
first->next = NULL;
|
||||
cptr += ALIGN(sizeof(struct memblock), sizeof(void*));
|
||||
first->len = len - (cptr - (char*) ptr);
|
||||
first->flags = 0;
|
||||
mt->_vd = (void*) first;
|
||||
cptr += ALIGN(sizeof(struct memtype), sizeof(void *));
|
||||
|
||||
/* Initialize first free memblock */
|
||||
mb = (struct memblock *) cptr;
|
||||
mb->prev = NULL;
|
||||
mb->next = NULL;
|
||||
mb->flags = 0;
|
||||
|
||||
cptr += ALIGN(sizeof(struct memblock), sizeof(void *));
|
||||
|
||||
mb->len = len - (cptr - (char *) ptr);
|
||||
|
||||
mt->_vd = (void *) mb;
|
||||
|
||||
return mt;
|
||||
}
|
||||
|
|
@ -241,8 +267,7 @@ struct memtype memtype_heap = {
|
|||
.flags = MEMORY_HEAP,
|
||||
.alloc = memory_heap_alloc,
|
||||
.free = memory_heap_free,
|
||||
.alignment = 1,
|
||||
._vd = NULL,
|
||||
.alignment = 1
|
||||
};
|
||||
|
||||
struct memtype memtype_hugepage = {
|
||||
|
|
@ -250,14 +275,5 @@ struct memtype memtype_hugepage = {
|
|||
.flags = MEMORY_MMAP | MEMORY_HUGEPAGE,
|
||||
.alloc = memory_hugepage_alloc,
|
||||
.free = memory_hugepage_free,
|
||||
.alignment = 21, /* 2 MiB hugepage */
|
||||
._vd = NULL,
|
||||
};
|
||||
|
||||
/** @todo */
|
||||
const struct memtype memtype_dma = {
|
||||
.name = "dma",
|
||||
.flags = MEMORY_DMA | MEMORY_MMAP,
|
||||
.alloc = NULL, .free = NULL,
|
||||
.alignment = 12
|
||||
.alignment = 21 /* 2 MiB hugepage */
|
||||
};
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue