Subversion Repositories HelenOS

Rev

Rev 2131 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
692 bondari 1
/*
2071 jermar 2
 * Copyright (c) 2006 Sergey Bondari
692 bondari 3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
2028 decky 28
 
692 bondari 29
#include <print.h>
30
#include <test.h>
31
#include <mm/page.h>
32
#include <mm/frame.h>
814 palkovsky 33
#include <mm/slab.h>
692 bondari 34
#include <arch/mm/page.h>
35
#include <arch/types.h>
1104 jermar 36
#include <atomic.h>
692 bondari 37
#include <debug.h>
38
#include <proc/thread.h>
39
#include <memstr.h>
745 jermar 40
#include <arch.h>
692 bondari 41
 
735 bondari 42
#define MAX_FRAMES 256
43
#define MAX_ORDER 8
692 bondari 44
 
733 bondari 45
#define THREAD_RUNS 1
735 bondari 46
#define THREADS 8
692 bondari 47
 
48
static atomic_t thread_count;
2028 decky 49
static atomic_t thread_fail;
2053 decky 50
static bool sh_quiet;
692 bondari 51
 
2028 decky 52
static void falloc(void * arg)
745 jermar 53
{
1767 palkovsky 54
    int order, run, allocated, i;
1780 jermar 55
    uint8_t val = THREAD->tid % THREADS;
733 bondari 56
    index_t k;
692 bondari 57
 
1780 jermar 58
    uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
2028 decky 59
    if (frames == NULL) {
2053 decky 60
        if (!sh_quiet)
2307 hudecek 61
            printf("Thread #%llu (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
2028 decky 62
        atomic_inc(&thread_fail);
63
        atomic_dec(&thread_count);
64
        return;
65
    }
1658 vana 66
 
67
    thread_detach(THREAD);
692 bondari 68
 
745 jermar 69
    for (run = 0; run < THREAD_RUNS; run++) {
70
        for (order = 0; order <= MAX_ORDER; order++) {
2053 decky 71
            if (!sh_quiet)
2307 hudecek 72
                printf("Thread #%llu (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
2053 decky 73
 
692 bondari 74
            allocated = 0;
745 jermar 75
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
1780 jermar 76
                frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
1767 palkovsky 77
                if (frames[allocated]) {
745 jermar 78
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
692 bondari 79
                    allocated++;
2028 decky 80
                } else
692 bondari 81
                    break;
82
            }
2053 decky 83
 
84
            if (!sh_quiet)
2307 hudecek 85
                printf("Thread #%llu (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
2053 decky 86
 
87
            if (!sh_quiet)
2307 hudecek 88
                printf("Thread #%llu (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
2053 decky 89
 
745 jermar 90
            for (i = 0; i < allocated; i++) {
91
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
1780 jermar 92
                    if (((uint8_t *) frames[i])[k] != val) {
2053 decky 93
                        if (!sh_quiet)
2307 hudecek 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);
2028 decky 95
                        atomic_inc(&thread_fail);
96
                        goto cleanup;
733 bondari 97
                    }
98
                }
1760 palkovsky 99
                frame_free(KA2PA(frames[i]));
692 bondari 100
            }
2053 decky 101
 
102
            if (!sh_quiet)
2307 hudecek 103
                printf("Thread #%llu (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
692 bondari 104
        }
105
    }
2028 decky 106
 
107
cleanup:   
745 jermar 108
    free(frames);
2053 decky 109
 
110
    if (!sh_quiet)
2307 hudecek 111
        printf("Thread #%llu (cpu%d): Exiting\n", THREAD->tid, CPU->id);
692 bondari 112
    atomic_dec(&thread_count);
113
}
114
 
2050 decky 115
char * test_falloc2(bool quiet)
745 jermar 116
{
2028 decky 117
    unsigned int i;
2053 decky 118
    sh_quiet = quiet;
692 bondari 119
 
120
    atomic_set(&thread_count, THREADS);
2028 decky 121
    atomic_set(&thread_fail, 0);
692 bondari 122
 
745 jermar 123
    for (i = 0; i < THREADS; i++) {
2042 decky 124
        thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc", false);
2028 decky 125
        if (!thrd) {
2053 decky 126
            if (!quiet)
127
                printf("Could not create thread %d\n", i);
2028 decky 128
            break;
129
        }
130
        thread_ready(thrd);
692 bondari 131
    }
132
 
2028 decky 133
    while (atomic_get(&thread_count) > 0) {
2053 decky 134
        if (!quiet)
135
            printf("Threads left: %d\n", atomic_get(&thread_count));
2028 decky 136
        thread_sleep(1);
137
    }
138
 
139
    if (atomic_get(&thread_fail) == 0)
140
        return NULL;
141
 
142
    return "Test failed";
692 bondari 143
}