/kernel/trunk/test/mm/falloc1/test.c |
---|
29,16 → 29,17 |
#include <test.h> |
#include <mm/page.h> |
#include <mm/frame.h> |
#include <mm/heap.h> |
#include <arch/mm/page.h> |
#include <arch/types.h> |
#include <debug.h> |
#define MAX_FRAMES 2048 |
#define MAX_FRAMES 1024 |
#define MAX_ORDER 8 |
#define TEST_RUNS 4 |
#define TEST_RUNS 2 |
void test(void) { |
__address frames[MAX_FRAMES]; |
__address * frames = (__address *) malloc(MAX_FRAMES*sizeof(__address)); |
int results[MAX_ORDER+1]; |
int i, order, run; |
52,7 → 53,7 |
printf("Allocating %d frames blocks ... ", 1<<order); |
allocated = 0; |
for (i=0;i<MAX_FRAMES>>order;i++) { |
frames[allocated] = frame_alloc(FRAME_NON_BLOCKING, order, &status); |
frames[allocated] = frame_alloc(FRAME_NON_BLOCKING | FRAME_KA, order, &status); |
if (frames[allocated] % (FRAME_SIZE << order) != 0) { |
panic("Test failed. Block at address %X (size %dK) is not aligned\n", frames[allocated], (FRAME_SIZE << order) >> 10); |
82,7 → 83,7 |
} |
} |
free(frames); |
printf("Test passed\n"); |
} |
/kernel/trunk/test/mm/falloc2/test.c |
---|
29,6 → 29,7 |
#include <test.h> |
#include <mm/page.h> |
#include <mm/frame.h> |
#include <mm/heap.h> |
#include <arch/mm/page.h> |
#include <arch/types.h> |
#include <arch/atomic.h> |
36,11 → 37,11 |
#include <proc/thread.h> |
#include <memstr.h> |
#define MAX_FRAMES 128 |
#define MAX_ORDER 2 |
#define MAX_FRAMES 256 |
#define MAX_ORDER 8 |
#define THREAD_RUNS 1 |
#define THREADS 6 |
#define THREADS 8 |
static void thread(void * arg); |
static void failed(void); |
53,7 → 54,7 |
__u8 val = *((__u8 *) arg); |
index_t k; |
__address frames[MAX_FRAMES]; |
__address * frames = (__address *) malloc(MAX_FRAMES * sizeof(__address)); |
for (run=0;run<THREAD_RUNS;run++) { |
60,7 → 61,7 |
for (order=0;order<=MAX_ORDER;order++) { |
printf("Thread #%d: Allocating %d frames blocks ... \n",val, 1<<order); |
allocated = 0; |
for (i=0;i<MAX_FRAMES>>order;i++) { |
for (i=0;i < (MAX_FRAMES >> order);i++) { |
frames[allocated] = frame_alloc(FRAME_NON_BLOCKING | FRAME_KA,order, &status); |
if (status == 0) { |
memsetb(frames[allocated], (1 << order) * FRAME_SIZE, val); |
74,6 → 75,7 |
printf("Thread #%d: Deallocating ... \n", val); |
for (i=0;i<allocated;i++) { |
for (k=0;k<=((FRAME_SIZE << order) - 1);k++) { |
if ( ((char *) frames[i])[k] != val ) { |
printf("Thread #%d: Unexpected data in block %P offset %X\n",val, frames[i], k); |
81,7 → 83,7 |
} |
} |
frame_free(frames[i]); |
} |
printf("Thread #%d: Finished run.\n", val); |
/kernel/trunk/generic/include/mm/buddy.h |
---|
45,7 → 45,7 |
}; |
struct buddy_system { |
__u8 max_order; |
__u8 max_order; /**< Maximal order of block which can be stored by buddy system. */ |
link_t *order; |
buddy_system_operations_t *op; |
void *data; /**< Pointer to be used by the implementation. */ |
/kernel/trunk/generic/src/mm/buddy.c |
---|
68,13 → 68,13 |
/* |
* Allocate memory for all orders this buddy system will work with. |
*/ |
b->order = (link_t *) early_malloc(max_order * sizeof(link_t)); |
b->order = (link_t *) early_malloc((max_order + 1) * sizeof(link_t)); |
if (!b->order) { |
early_free(b); |
return NULL; |
} |
for (i = 0; i < max_order; i++) |
for (i = 0; i <= max_order; i++) |
list_initialize(&b->order[i]); |
b->max_order = max_order; |
95,9 → 95,16 |
bool buddy_system_can_alloc(buddy_system_t *b, __u8 i) { |
__u8 k; |
ASSERT(i < b->max_order); |
for (k=i; k < b->max_order; k++) { |
/* |
* If requested block is greater then maximal block |
* we know immediatly that we cannot satisfy the request. |
*/ |
if (i > b->max_order) return false; |
/* |
* Check if any bigger or equal order has free elements |
*/ |
for (k=i; k <= b->max_order; k++) { |
if (!list_empty(&b->order[k])) { |
return true; |
} |
118,7 → 125,7 |
{ |
link_t *res, *hlp; |
ASSERT(i < b->max_order); |
ASSERT(i <= b->max_order); |
/* |
* If the list of order i is not empty, |
135,7 → 142,7 |
* If order i is already the maximal order, |
* the request cannot be satisfied. |
*/ |
if (i == b->max_order - 1) |
if (i == b->max_order) |
return NULL; |
/* |
185,9 → 192,9 |
*/ |
i = b->op->get_order(b, block); |
ASSERT(i < b->max_order); |
ASSERT(i <= b->max_order); |
if (i != b->max_order - 1) { |
if (i != b->max_order) { |
/* |
* See if there is any buddy in the list of order i. |
*/ |
245,7 → 252,7 |
printf("Order\tBlocks\tSize \tBlock size\tElems per block\n"); |
printf("-----\t------\t--------\t----------\t---------------\n"); |
for (i=0;i < b->max_order; i++) { |
for (i=0;i <= b->max_order; i++) { |
cnt = 0; |
if (!list_empty(&b->order[i])) { |
for (cur = b->order[i].next; cur != &b->order[i]; cur = cur->next) |
/kernel/trunk/generic/src/mm/frame.c |
---|
152,6 → 152,8 |
spinlock_unlock(&zone_head_lock); |
interrupts_restore(ipl); |
ASSERT(v == ALIGN_UP(v, FRAME_SIZE << order)); |
if (flags & FRAME_KA) |
v = PA2KA(v); |