Subversion Repositories HelenOS

Rev

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

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