Subversion Repositories HelenOS-historic

Compare Revisions

Ignore whitespace Rev 734 → Rev 735

/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);