Subversion Repositories HelenOS

Rev

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

Rev 2050 Rev 2053
Line 45... Line 45...
45 
#define THREAD_RUNS 1
 45 
#define THREAD_RUNS 1
46 
#define THREADS 8
 46 
#define THREADS 8
47 
 
 47 
 
48 
static atomic_t thread_count;
 48 
static atomic_t thread_count;
49 
static atomic_t thread_fail;
 49 
static atomic_t thread_fail;
- 
 
 50 
static bool sh_quiet;
50 
 
 51 
 
51 
static void falloc(void * arg)
 52 
static void falloc(void * arg)
52 
{
 53 
{
53 
    int order, run, allocated, i;
 54 
    int order, run, allocated, i;
54 
    uint8_t val = THREAD->tid % THREADS;
 55 
    uint8_t val = THREAD->tid % THREADS;
55 
    index_t k;
 56 
    index_t k;
56 
   
 57 
   
57 
    uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
 58 
    uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
58 
    if (frames == NULL) {
 59 
    if (frames == NULL) {
- 
 
 60 
        if (!sh_quiet)
59 
        printf("Thread #%d (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
 61 
            printf("Thread #%d (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
60 
        atomic_inc(&thread_fail);
 62 
        atomic_inc(&thread_fail);
61 
        atomic_dec(&thread_count);
 63 
        atomic_dec(&thread_count);
62 
        return;
 64 
        return;
63 
    }
 65 
    }
64 
   
 66 
   
65 
    thread_detach(THREAD);
 67 
    thread_detach(THREAD);
66 
 
 68 
 
67 
    for (run = 0; run < THREAD_RUNS; run++) {
 69 
    for (run = 0; run < THREAD_RUNS; run++) {
68 
        for (order = 0; order <= MAX_ORDER; order++) {
 70 
        for (order = 0; order <= MAX_ORDER; order++) {
- 
 
 71 
            if (!sh_quiet)
69 
            printf("Thread #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
 72 
                printf("Thread #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
- 
 
 73 
           
70 
            allocated = 0;
 74 
            allocated = 0;
71 
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
 75 
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
72 
                frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
 76 
                frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
73 
                if (frames[allocated]) {
 77 
                if (frames[allocated]) {
74 
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
 78 
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
75 
                    allocated++;
 79 
                    allocated++;
76 
                } else
 80 
                } else
77 
                    break;
 81 
                    break;
78 
            }
 82 
            }
- 
 
 83 
           
- 
 
 84 
            if (!sh_quiet)
79 
            printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
 85 
                printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
80 
 
 86 
           
- 
 
 87 
            if (!sh_quiet)
81 
            printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
 88 
                printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
- 
 
 89 
           
82 
            for (i = 0; i < allocated; i++) {
 90 
            for (i = 0; i < allocated; i++) {
83 
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
 91 
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
84 
                    if (((uint8_t *) frames[i])[k] != val) {
 92 
                    if (((uint8_t *) frames[i])[k] != val) {
- 
 
 93 
                        if (!sh_quiet)
85 
                        printf("Thread #%d (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
 94 
                            printf("Thread #%d (cpu%d): Unexpected data (%d) in block %p offset %#zx\n", THREAD->tid, CPU->id, ((char *) frames[i])[k], frames[i], k);
86 
                        atomic_inc(&thread_fail);
 95 
                        atomic_inc(&thread_fail);
87 
                        goto cleanup;
 96 
                        goto cleanup;
88 
                    }
 97 
                    }
89 
                }
 98 
                }
90 
                frame_free(KA2PA(frames[i]));
 99 
                frame_free(KA2PA(frames[i]));
91 
            }
 100 
            }
- 
 
 101 
           
- 
 
 102 
            if (!sh_quiet)
92 
            printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
 103 
                printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
93 
        }
 104 
        }
94 
    }
 105 
    }
95 
 
 106 
 
96 
cleanup:   
 107 
cleanup:   
97 
    free(frames);
 108 
    free(frames);
- 
 
 109 
   
- 
 
 110 
    if (!sh_quiet)
98 
    printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
 111 
        printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
99 
    atomic_dec(&thread_count);
 112 
    atomic_dec(&thread_count);
100 
}
 113 
}
101 
 
 114 
 
102 
char * test_falloc2(bool quiet)
 115 
char * test_falloc2(bool quiet)
103 
{
 116 
{
104 
    unsigned int i;
 117 
    unsigned int i;
- 
 
 118 
    sh_quiet = quiet;
105 
 
 119 
 
106 
    atomic_set(&thread_count, THREADS);
 120 
    atomic_set(&thread_count, THREADS);
107 
    atomic_set(&thread_fail, 0);
 121 
    atomic_set(&thread_fail, 0);
108 
       
 122 
       
109 
    for (i = 0; i < THREADS; i++) {
 123 
    for (i = 0; i < THREADS; i++) {
110 
        thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc", false);
 124 
        thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc", false);
111 
        if (!thrd) {
 125 
        if (!thrd) {
- 
 
 126 
            if (!quiet)
112 
            printf("Could not create thread %d\n", i);
 127 
                printf("Could not create thread %d\n", i);
113 
            break;
 128 
            break;
114 
        }
 129 
        }
115 
        thread_ready(thrd);
 130 
        thread_ready(thrd);
116 
    }
 131 
    }
117 
   
 132 
   
118 
    while (atomic_get(&thread_count) > 0) {
 133 
    while (atomic_get(&thread_count) > 0) {
- 
 
 134 
        if (!quiet)
119 
        printf("Threads left: %d\n", atomic_get(&thread_count));
 135 
            printf("Threads left: %d\n", atomic_get(&thread_count));
120 
        thread_sleep(1);
 136 
        thread_sleep(1);
121 
    }
 137 
    }
122 
   
 138 
   
123 
    if (atomic_get(&thread_fail) == 0)
 139 
    if (atomic_get(&thread_fail) == 0)
124 
        return NULL;
 140 
        return NULL;