Changeset 4a2f4bb in mainline

Timestamp:

2006-01-25T21:18:38Z (19 years ago)

Author:

Jakub Jermar <jakub@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

2a003d5b

Parents:

895be41

Message:

Fix and cleanup frame allocator tests.
falloc1:

• fix so that it compiles on ia64
• check that frames is not NULL

falloc2:

• threads cannot be passed argument in the way this test did (otherwise some threads will use the same value for val)
  • check that frames is not NULL
  • free frames at the end of the test

Location:

test/mm

Files:

• falloc1/test.c (modified) (5 diffs)
• falloc2/test.c (modified) (4 diffs)

test/mm/falloc1/test.c

@@ -34 +34 @@
 #include <arch/types.h>
 #include <debug.h>
+#include <align.h>
 
 #define MAX_FRAMES 1024
@@ -48 +49 @@
 
         ASSERT(TEST_RUNS > 1);
+        ASSERT(frames != NULL)
 
-        for (run=0;run<=TEST_RUNS;run++) {
-                for (order=0;order<=MAX_ORDER;order++) {
-                        printf("Allocating %d frames blocks ... ", 1<<order);
+        for (run = 0; run < TEST_RUNS; run++) {
+                for (order = 0; order <= MAX_ORDER; order++) {
+                        printf("Allocating %d frames blocks ... ", 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 (frames[allocated] % (FRAME_SIZE << order) != 0) {
+                                if (ALIGN_UP(frames[allocated], FRAME_SIZE << order) != frames[allocated]) {
                                         panic("Test failed. Block at address %X (size %dK) is not aligned\n", frames[allocated], (FRAME_SIZE << order) >> 10);
                                 }
@@ -68 +70 @@
                         }
                 
-                        printf("%d blocks alocated.\n", allocated);
+                        printf("%d blocks allocated.\n", allocated);
                 
                         if (run) {
@@ -74 +76 @@
                                         panic("Test failed. Frame leak possible.\n");
                                 }
-                        } else results[order] = allocated;
+                        } else
+                                results[order] = allocated;
                         
                         printf("Deallocating ... ");
-                        for (i=0;i<allocated;i++) {
+                        for (i = 0; i < allocated; i++) {
                                 frame_free(frames[i]);
                         }
@@ -86 +89 @@
         free(frames);
         
-        printf("Test passed\n");
+        printf("Test passed.\n");
 }
 

test/mm/falloc2/test.c

@@ -37 +37 @@
 #include <proc/thread.h>
 #include <memstr.h>
+#include <arch.h>
 
 #define MAX_FRAMES 256
@@ -49 +50 @@
 static atomic_t thread_count;
 
-void thread(void * arg) {
-        int status, order, run, allocated,i;
-        
-        __u8 val = *((__u8 *) arg);
+void thread(void * arg)
+{
+        int status, order, run, allocated, i;
+        __u8 val = THREAD->tid % THREADS;
         index_t k;
         
         __address * frames =  (__address *) malloc(MAX_FRAMES * sizeof(__address));
+        ASSERT(frames != NULL);
 
-        for (run=0;run<THREAD_RUNS;run++) {
-        
-                for (order=0;order<=MAX_ORDER;order++) {
-                        printf("Thread #%d: Allocating %d frames blocks ... \n",val, 1<<order);
+        for (run = 0; run < THREAD_RUNS; run++) {
+                for (order = 0; order <= MAX_ORDER; order++) {
+                        printf("Thread #%d: Allocating %d frames blocks ... \n", THREAD->tid, 1 << order);
                         allocated = 0;
-                        for (i=0;i < (MAX_FRAMES >> order);i++) {
-                                frames[allocated] = frame_alloc(FRAME_NON_BLOCKING | FRAME_KA,order, &status);
+                        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);
+                                        memsetb(frames[allocated], FRAME_SIZE << order, val);
                                         allocated++;
                                 } else {
@@ -71 +72 @@
                                 }
                         }
-                
-                        printf("Thread #%d: %d blocks alocated.\n",val, allocated);
+                        printf("Thread #%d: %d blocks allocated.\n", THREAD->tid, allocated);
 
-                        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);
+                        printf("Thread #%d: Deallocating ... \n", THREAD->tid);
+                        for (i = 0; i < allocated; i++) {
+                                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
+                                        if (((__u8 *) frames[i])[k] != val) {
+                                                printf("Thread #%d: Unexpected data (%d) in block %P offset %X\n", THREAD->tid, ((char *) frames[i])[k], frames[i], k);
                                                 failed();
                                         }
-                                
                                 }
-                                
                                 frame_free(frames[i]);
                         }
@@ -91 +88 @@
         }
         
+        free(frames);
         
         atomic_dec(&thread_count);
-
 }
 
 
-void failed(void) {
+void failed(void)
+{
         panic("Test failed.\n");
 }
 
 
-void test(void) {
+void test(void)
+{
         int i;
 
         atomic_set(&thread_count, THREADS);
                 
-        for (i=1;i<=THREADS;i++) {
+        for (i = 0; i < THREADS; i++) {
                 thread_t * thrd;
-                thrd = thread_create(thread, &i, TASK, 0);
-                if (thrd) thread_ready(thrd); else failed();
+                thrd = thread_create(thread, NULL, TASK, 0);
+                if (thrd)
+                        thread_ready(thrd);
+                else
+                        failed();
         }
         
-        while (thread_count.count);
+        while (thread_count.count)
+                ;
 
-        printf("Test passed\n");
+        printf("Test passed.\n");
 }
-