Subversion Repositories HelenOS

Rev

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

Rev 3186 Rev 4227
Line 34... Line 34...
34
#include <mm/frame.h>
34
#include <mm/frame.h>
35
#include <memstr.h>
35
#include <memstr.h>
36
#include <synch/condvar.h>
36
#include <synch/condvar.h>
37
#include <synch/mutex.h>
37
#include <synch/mutex.h>
38
 
38
 
39
#define ITEM_SIZE 256
39
#define ITEM_SIZE  256
40
 
40
 
41
/** Fill memory with 2 caches, when allocation fails,
41
/** Fill memory with 2 caches, when allocation fails,
42
 *  free one of the caches. We should have everything in magazines,
42
 *  free one of the caches. We should have everything in magazines,
43
 *  now allocation should clean magazines and allow for full allocation.
43
 *  now allocation should clean magazines and allow for full allocation.
44
 */
44
 */
45
static void totalmemtest(bool quiet)
45
static void totalmemtest(void)
46
{
46
{
47
    slab_cache_t *cache1;
47
    slab_cache_t *cache1;
48
    slab_cache_t *cache2;
48
    slab_cache_t *cache2;
49
    int i;
49
    int i;
50
 
50
   
51
    void *data1, *data2;
51
    void *data1, *data2;
52
    void *olddata1 = NULL, *olddata2 = NULL;
52
    void *olddata1 = NULL, *olddata2 = NULL;
53
   
53
   
54
    cache1 = slab_cache_create("cache1_tst", ITEM_SIZE, 0, NULL, NULL, 0);
54
    cache1 = slab_cache_create("cache1_tst", ITEM_SIZE, 0, NULL, NULL, 0);
55
    cache2 = slab_cache_create("cache2_tst", ITEM_SIZE, 0, NULL, NULL, 0);
55
    cache2 = slab_cache_create("cache2_tst", ITEM_SIZE, 0, NULL, NULL, 0);
56
   
56
   
57
    if (!quiet)
-
 
58
        printf("Allocating...");
57
    TPRINTF("Allocating...");
59
   
58
   
60
    /* Use atomic alloc, so that we find end of memory */
59
    /* Use atomic alloc, so that we find end of memory */
61
    do {
60
    do {
62
        data1 = slab_alloc(cache1, FRAME_ATOMIC);
61
        data1 = slab_alloc(cache1, FRAME_ATOMIC);
63
        data2 = slab_alloc(cache2, FRAME_ATOMIC);
62
        data2 = slab_alloc(cache2, FRAME_ATOMIC);
Line 72... Line 71...
72
        memsetb(data2, ITEM_SIZE, 0);
71
        memsetb(data2, ITEM_SIZE, 0);
73
        *((void **) data1) = olddata1;
72
        *((void **) data1) = olddata1;
74
        *((void **) data2) = olddata2;
73
        *((void **) data2) = olddata2;
75
        olddata1 = data1;
74
        olddata1 = data1;
76
        olddata2 = data2;
75
        olddata2 = data2;
77
    } while (1);
76
    } while (true);
78
   
77
   
79
    if (!quiet) {
-
 
80
        printf("done.\n");
78
    TPRINTF("done.\n");
-
 
79
   
81
        printf("Deallocating cache2...");
80
    TPRINTF("Deallocating cache2...");
82
    }
-
 
83
   
81
   
84
    /* We do not have memory - now deallocate cache2 */
82
    /* We do not have memory - now deallocate cache2 */
85
    while (olddata2) {
83
    while (olddata2) {
86
        data2 = *((void **) olddata2);
84
        data2 = *((void **) olddata2);
87
        slab_free(cache2, olddata2);
85
        slab_free(cache2, olddata2);
88
        olddata2 = data2;
86
        olddata2 = data2;
89
    }
87
    }
90
   
88
   
91
    if (!quiet) {
-
 
92
        printf("done.\n");
89
    TPRINTF("done.\n");
-
 
90
   
93
        printf("Allocating to cache1...\n");
91
    TPRINTF("Allocating to cache1...\n");
94
    }
-
 
95
   
92
   
96
    for (i = 0; i < 30; i++) {
93
    for (i = 0; i < 30; i++) {
97
        data1 = slab_alloc(cache1, FRAME_ATOMIC);
94
        data1 = slab_alloc(cache1, FRAME_ATOMIC);
98
        if (!data1) {
95
        if (!data1) {
99
            if (!quiet)
-
 
100
                printf("Incorrect memory size - use another test.");
96
            TPRINTF("Incorrect memory size - use another test.");
101
            return;
97
            return;
102
        }
98
        }
103
        memsetb(data1, ITEM_SIZE, 0);
99
        memsetb(data1, ITEM_SIZE, 0);
104
        *((void **) data1) = olddata1;
100
        *((void **) data1) = olddata1;
105
        olddata1 = data1;
101
        olddata1 = data1;
106
    }
102
    }
107
    while (1) {
103
    while (true) {
108
        data1 = slab_alloc(cache1, FRAME_ATOMIC);
104
        data1 = slab_alloc(cache1, FRAME_ATOMIC);
109
        if (!data1)
105
        if (!data1)
110
            break;
106
            break;
111
        memsetb(data1, ITEM_SIZE, 0);
107
        memsetb(data1, ITEM_SIZE, 0);
112
        *((void **) data1) = olddata1;
108
        *((void **) data1) = olddata1;
113
        olddata1 = data1;
109
        olddata1 = data1;
114
    }
110
    }
115
   
111
   
116
    if (!quiet)
-
 
117
        printf("Deallocating cache1...");
112
    TPRINTF("Deallocating cache1...");
118
   
113
   
119
    while (olddata1) {
114
    while (olddata1) {
120
        data1 = *((void **) olddata1);
115
        data1 = *((void **) olddata1);
121
        slab_free(cache1, olddata1);
116
        slab_free(cache1, olddata1);
122
        olddata1 = data1;
117
        olddata1 = data1;
123
    }
118
    }
124
   
119
   
125
    if (!quiet) {
-
 
126
        printf("done.\n");
120
    TPRINTF("done.\n");
-
 
121
   
127
        slab_print_list();
122
    slab_print_list();
128
    }
-
 
129
   
123
   
130
    slab_cache_destroy(cache1);
124
    slab_cache_destroy(cache1);
131
    slab_cache_destroy(cache2);
125
    slab_cache_destroy(cache2);
132
}
126
}
133
 
127
 
134
static slab_cache_t *thr_cache;
128
static slab_cache_t *thr_cache;
135
static semaphore_t thr_sem;
129
static semaphore_t thr_sem;
136
static condvar_t thread_starter;
130
static condvar_t thread_starter;
137
static mutex_t starter_mutex;
131
static mutex_t starter_mutex;
138
static bool sh_quiet;
-
 
139
 
132
 
140
#define THREADS 8
133
#define THREADS  8
141
 
134
 
142
static void slabtest(void *priv)
135
static void slabtest(void *priv)
143
{
136
{
144
    void *data = NULL, *new;
137
    void *data = NULL, *new;
145
   
138
   
Line 147... Line 140...
147
   
140
   
148
    mutex_lock(&starter_mutex);
141
    mutex_lock(&starter_mutex);
149
    condvar_wait(&thread_starter,&starter_mutex);
142
    condvar_wait(&thread_starter,&starter_mutex);
150
    mutex_unlock(&starter_mutex);
143
    mutex_unlock(&starter_mutex);
151
   
144
   
152
    if (!sh_quiet)
-
 
153
        printf("Starting thread #%" PRIu64 "...\n", THREAD->tid);
145
    TPRINTF("Starting thread #%" PRIu64 "...\n", THREAD->tid);
154
 
146
 
155
    /* Alloc all */
147
    /* Alloc all */
156
    if (!sh_quiet)
-
 
157
        printf("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
148
    TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
158
   
149
   
159
    while (1) {
150
    while (true) {
160
        /* Call with atomic to detect end of memory */
151
        /* Call with atomic to detect end of memory */
161
        new = slab_alloc(thr_cache, FRAME_ATOMIC);
152
        new = slab_alloc(thr_cache, FRAME_ATOMIC);
162
        if (!new)
153
        if (!new)
163
            break;
154
            break;
164
        *((void **) new) = data;
155
        *((void **) new) = data;
165
        data = new;
156
        data = new;
166
    }
157
    }
167
   
158
   
168
    if (!sh_quiet)
-
 
169
        printf("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
159
    TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
170
   
160
   
171
    while (data) {
161
    while (data) {
172
        new = *((void **)data);
162
        new = *((void **)data);
173
        *((void **) data) = NULL;
163
        *((void **) data) = NULL;
174
        slab_free(thr_cache, data);
164
        slab_free(thr_cache, data);
175
        data = new;
165
        data = new;
176
    }
166
    }
177
   
167
   
178
    if (!sh_quiet)
-
 
179
        printf("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
168
    TPRINTF("Thread #%" PRIu64 " allocating...\n", THREAD->tid);
180
   
169
   
181
    while (1) {
170
    while (true) {
182
        /* Call with atomic to detect end of memory */
171
        /* Call with atomic to detect end of memory */
183
        new = slab_alloc(thr_cache, FRAME_ATOMIC);
172
        new = slab_alloc(thr_cache, FRAME_ATOMIC);
184
        if (!new)
173
        if (!new)
185
            break;
174
            break;
186
        *((void **) new) = data;
175
        *((void **) new) = data;
187
        data = new;
176
        data = new;
188
    }
177
    }
189
   
178
   
190
    if (!sh_quiet)
-
 
191
        printf("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
179
    TPRINTF("Thread #%" PRIu64 " releasing...\n", THREAD->tid);
192
   
180
   
193
    while (data) {
181
    while (data) {
194
        new = *((void **)data);
182
        new = *((void **)data);
195
        *((void **) data) = NULL;
183
        *((void **) data) = NULL;
196
        slab_free(thr_cache, data);
184
        slab_free(thr_cache, data);
197
        data = new;
185
        data = new;
198
    }
186
    }
199
   
187
   
200
    if (!sh_quiet)
-
 
201
        printf("Thread #%" PRIu64 " finished\n", THREAD->tid);
188
    TPRINTF("Thread #%" PRIu64 " finished\n", THREAD->tid);
202
   
189
   
203
    slab_print_list();
190
    slab_print_list();
204
    semaphore_up(&thr_sem);
191
    semaphore_up(&thr_sem);
205
}
192
}
206
 
193
 
207
static void multitest(int size, bool quiet)
194
static void multitest(int size)
208
{
195
{
209
    /* Start 8 threads that just allocate as much as possible,
196
    /* Start 8 threads that just allocate as much as possible,
210
     * then release everything, then again allocate, then release
197
     * then release everything, then again allocate, then release
211
     */
198
     */
212
    thread_t *t;
199
    thread_t *t;
213
    int i;
200
    int i;
214
   
201
   
215
    if (!quiet)
-
 
216
        printf("Running stress test with size %d\n", size);
202
    TPRINTF("Running stress test with size %d\n", size);
217
   
203
   
218
    condvar_initialize(&thread_starter);
204
    condvar_initialize(&thread_starter);
219
    mutex_initialize(&starter_mutex, MUTEX_PASSIVE);
205
    mutex_initialize(&starter_mutex, MUTEX_PASSIVE);
220
 
206
   
221
    thr_cache = slab_cache_create("thread_cache", size, 0, NULL, NULL, 0);
207
    thr_cache = slab_cache_create("thread_cache", size, 0, NULL, NULL, 0);
222
    semaphore_initialize(&thr_sem,0);
208
    semaphore_initialize(&thr_sem,0);
223
    for (i = 0; i < THREADS; i++) {  
209
    for (i = 0; i < THREADS; i++) {  
224
        if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false))) {
210
        if (!(t = thread_create(slabtest, NULL, TASK, 0, "slabtest", false))) {
225
            if (!quiet)
-
 
226
                printf("Could not create thread %d\n", i);
211
            TPRINTF("Could not create thread %d\n", i);
227
        } else
212
        } else
228
            thread_ready(t);
213
            thread_ready(t);
229
    }
214
    }
230
    thread_sleep(1);
215
    thread_sleep(1);
231
    condvar_broadcast(&thread_starter);
216
    condvar_broadcast(&thread_starter);
232
 
217
   
233
    for (i = 0; i < THREADS; i++)
218
    for (i = 0; i < THREADS; i++)
234
        semaphore_down(&thr_sem);
219
        semaphore_down(&thr_sem);
235
   
220
   
236
    slab_cache_destroy(thr_cache);
221
    slab_cache_destroy(thr_cache);
237
    if (!quiet)
-
 
238
        printf("Stress test complete.\n");
222
    TPRINTF("Stress test complete.\n");
239
}
223
}
240
 
224
 
241
char * test_slab2(bool quiet)
225
char *test_slab2(void)
242
{
226
{
-
 
227
    TPRINTF("Running reclaim single-thread test .. pass 1\n");
-
 
228
    totalmemtest();
-
 
229
   
-
 
230
    TPRINTF("Running reclaim single-thread test .. pass 2\n");
243
    sh_quiet = quiet;
231
    totalmemtest();
-
 
232
   
-
 
233
    TPRINTF("Reclaim test OK.\n");
244
   
234
   
245
    if (!quiet)
-
 
246
        printf("Running reclaim single-thread test .. pass 1\n");
-
 
247
    totalmemtest(quiet);
-
 
248
    if (!quiet)
-
 
249
        printf("Running reclaim single-thread test .. pass 2\n");
-
 
250
    totalmemtest(quiet);
-
 
251
    if (!quiet)
-
 
252
        printf("Reclaim test OK.\n");
-
 
253
   
-
 
254
    multitest(128, quiet);
235
    multitest(128);
255
    multitest(2048, quiet);
236
    multitest(2048);
256
    multitest(8192, quiet);
237
    multitest(8192);
257
   
238
   
258
    return NULL;
239
    return NULL;
259
}
240
}