Subversion Repositories HelenOS

Rev

Rev 692 | Rev 735 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 692 Rev 733
Line 35... Line 35...
35 
#include <debug.h>
 35 
#include <debug.h>
36 
#include <proc/thread.h>
 36 
#include <proc/thread.h>
37 
#include <memstr.h>
 37 
#include <memstr.h>
38 
 
 38 
 
39 
#define MAX_FRAMES 128
 39 
#define MAX_FRAMES 128
40 
#define MAX_ORDER 3
 40 
#define MAX_ORDER 2
41 
 
 41 
 
42 
#define THREAD_RUNS 2
 42 
#define THREAD_RUNS 1
43 
#define THREADS 6
 43 
#define THREADS 6
44 
 
 44 
 
45 
static void thread(void * arg);
 45 
static void thread(void * arg);
46 
static void failed(void);
 46 
static void failed(void);
47 
 
 47 
 
Line 49... Line 49...
49 
 
 49 
 
50 
void thread(void * arg) {
 50 
void thread(void * arg) {
51 
    int status, order, run, allocated,i;
 51 
    int status, order, run, allocated,i;
52 
   
 52 
   
53 
    __u8 val = *((__u8 *) arg);
 53 
    __u8 val = *((__u8 *) arg);
- 
 
 54 
    index_t k;
54 
   
 55 
   
55 
    __address frames[MAX_FRAMES];
 56 
    __address frames[MAX_FRAMES];
56 
 
 57 
 
57 
    for (run=0;run<THREAD_RUNS;run++) {
 58 
    for (run=0;run<THREAD_RUNS;run++) {
58 
   
 59 
   
59 
        for (order=0;order<=MAX_ORDER;order++) {
 60 
        for (order=0;order<=MAX_ORDER;order++) {
60 
            printf("Allocating %d frames blocks ... ", 1<<order);
 61 
            printf("Thread #%d: Allocating %d frames blocks ... \n",val, 1<<order);
61 
            allocated = 0;
 62 
            allocated = 0;
62 
            for (i=0;i<MAX_FRAMES>>order;i++) {
 63 
            for (i=0;i<MAX_FRAMES>>order;i++) {
63 
                frames[allocated] = frame_alloc(FRAME_NON_BLOCKING | FRAME_KA,order, &status);
 64 
                frames[allocated] = frame_alloc(FRAME_NON_BLOCKING | FRAME_KA,order, &status);
64 
                if (status == 0) {
 65 
                if (status == 0) {
65 
                    memsetb(frames[allocated], (1 << order) * FRAME_SIZE - 1, val);
 66 
                    memsetb(frames[allocated], (1 << order) * FRAME_SIZE, val);
66 
                    allocated++;
 67 
                    allocated++;
67 
                } else {
 68 
                } else {
68 
                    break;
 69 
                    break;
69 
                }
 70 
                }
70 
            }
 71 
            }
71 
       
 72 
       
72 
            printf("%d blocks alocated.\n", allocated);
 73 
            printf("Thread #%d: %d blocks alocated.\n",val, allocated);
73 
 
 74 
 
74 
            printf("Deallocating ... ");
 75 
            printf("Thread #%d: Deallocating ... \n", val);
75 
            for (i=0;i<allocated;i++) {
 76 
            for (i=0;i<allocated;i++) {
- 
 
 77 
                for (k=0;k<=((FRAME_SIZE << order) - 1);k++) {
- 
 
 78 
                    if ( ((char *) frames[i])[k] != val ) {
- 
 
 79 
                        printf("Thread #%d: Unexpected data in block %P offset %X\n",val, frames[i], k);
76 
                /* add memtest here */
 80 
                        failed();
- 
 
 81 
                    }
- 
 
 82 
               
- 
 
 83 
                }
- 
 
 84 
           
77 
                frame_free(frames[i]);
 85 
                frame_free(frames[i]);
78 
            }
 86 
            }
79 
            printf("done.\n");
 87 
            printf("Thread #%d: Finished run.\n", val);
80 
        }
 88 
        }
81 
    }
 89 
    }
82 
   
 90 
   
83 
   
 91 
   
84 
    atomic_dec(&thread_count);
 92 
    atomic_dec(&thread_count);