Subversion Repositories HelenOS

Rev

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

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