Subversion Repositories HelenOS

Rev

Rev 1658 | Rev 1767 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 1658 Rev 1760
1
/*
1
/*
2
 * Copyright (C) 2006 Sergey Bondari
2
 * Copyright (C) 2006 Sergey Bondari
3
 * All rights reserved.
3
 * All rights reserved.
4
 *
4
 *
5
 * Redistribution and use in source and binary forms, with or without
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
6
 * modification, are permitted provided that the following conditions
7
 * are met:
7
 * are met:
8
 *
8
 *
9
 * - Redistributions of source code must retain the above copyright
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
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
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.
15
 *   derived from this software without specific prior written permission.
16
 *
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
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
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
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
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
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
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.
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
27
 */
28
#include <print.h>
28
#include <print.h>
29
#include <test.h>
29
#include <test.h>
30
#include <mm/page.h>
30
#include <mm/page.h>
31
#include <mm/frame.h>
31
#include <mm/frame.h>
32
#include <mm/slab.h>
32
#include <mm/slab.h>
33
#include <arch/mm/page.h>
33
#include <arch/mm/page.h>
34
#include <arch/types.h>
34
#include <arch/types.h>
35
#include <atomic.h>
35
#include <atomic.h>
36
#include <debug.h>
36
#include <debug.h>
37
#include <proc/thread.h>
37
#include <proc/thread.h>
38
#include <memstr.h>
38
#include <memstr.h>
39
#include <arch.h>
39
#include <arch.h>
40
 
40
 
41
#define MAX_FRAMES 256
41
#define MAX_FRAMES 256
42
#define MAX_ORDER 8
42
#define MAX_ORDER 8
43
 
43
 
44
#define THREAD_RUNS 1
44
#define THREAD_RUNS 1
45
#define THREADS 8
45
#define THREADS 8
46
 
46
 
47
static void falloc(void * arg);
47
static void falloc(void * arg);
48
static void failed(void);
48
static void failed(void);
49
 
49
 
50
static atomic_t thread_count;
50
static atomic_t thread_count;
51
 
51
 
52
void falloc(void * arg)
52
void falloc(void * arg)
53
{
53
{
54
    int status, order, run, allocated, i;
54
    int status, order, run, allocated, i;
55
    __u8 val = THREAD->tid % THREADS;
55
    __u8 val = THREAD->tid % THREADS;
56
    index_t k;
56
    index_t k;
57
   
57
   
58
    __address * frames =  (__address *) malloc(MAX_FRAMES * sizeof(__address), FRAME_ATOMIC);
58
    __address * frames =  (__address *) malloc(MAX_FRAMES * sizeof(__address), FRAME_ATOMIC);
59
    ASSERT(frames != NULL);
59
    ASSERT(frames != NULL);
60
   
60
   
61
    thread_detach(THREAD);
61
    thread_detach(THREAD);
62
 
62
 
63
    for (run = 0; run < THREAD_RUNS; run++) {
63
    for (run = 0; run < THREAD_RUNS; run++) {
64
        for (order = 0; order <= MAX_ORDER; order++) {
64
        for (order = 0; order <= MAX_ORDER; order++) {
65
            printf("Thread #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
65
            printf("Thread #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
66
            allocated = 0;
66
            allocated = 0;
67
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
67
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
68
                frames[allocated] = PA2KA(PFN2ADDR(frame_alloc_rc(order, FRAME_ATOMIC | FRAME_KA, &status)));
68
                frames[allocated] = frame_alloc_rc(order, FRAME_ATOMIC | FRAME_KA, &status);
69
                if (status == 0) {
69
                if (status == 0) {
70
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
70
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
71
                    allocated++;
71
                    allocated++;
72
                } else {
72
                } else {
73
                    break;
73
                    break;
74
                }
74
                }
75
            }
75
            }
76
            printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
76
            printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
77
 
77
 
78
            printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
78
            printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
79
            for (i = 0; i < allocated; i++) {
79
            for (i = 0; i < allocated; i++) {
80
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
80
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
81
                    if (((__u8 *) frames[i])[k] != val) {
81
                    if (((__u8 *) frames[i])[k] != val) {
82
                        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);
82
                        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);
83
                        failed();
83
                        failed();
84
                    }
84
                    }
85
                }
85
                }
86
                frame_free(ADDR2PFN(KA2PA(frames[i])));
86
                frame_free(KA2PA(frames[i]));
87
            }
87
            }
88
            printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
88
            printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
89
        }
89
        }
90
    }
90
    }
91
   
91
   
92
    free(frames);
92
    free(frames);
93
    printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
93
    printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
94
    atomic_dec(&thread_count);
94
    atomic_dec(&thread_count);
95
}
95
}
96
 
96
 
97
 
97
 
98
void failed(void)
98
void failed(void)
99
{
99
{
100
    panic("Test failed.\n");
100
    panic("Test failed.\n");
101
}
101
}
102
 
102
 
103
 
103
 
104
void test(void)
104
void test(void)
105
{
105
{
106
    int i;
106
    int i;
107
 
107
 
108
    atomic_set(&thread_count, THREADS);
108
    atomic_set(&thread_count, THREADS);
109
       
109
       
110
    for (i = 0; i < THREADS; i++) {
110
    for (i = 0; i < THREADS; i++) {
111
        thread_t * thrd;
111
        thread_t * thrd;
112
        thrd = thread_create(falloc, NULL, TASK, 0, "falloc");
112
        thrd = thread_create(falloc, NULL, TASK, 0, "falloc");
113
        if (thrd)
113
        if (thrd)
114
            thread_ready(thrd);
114
            thread_ready(thrd);
115
        else
115
        else
116
            failed();
116
            failed();
117
    }
117
    }
118
   
118
   
119
    while (thread_count.count)
119
    while (thread_count.count)
120
        ;
120
        ;
121
 
121
 
122
    printf("Test passed.\n");
122
    printf("Test passed.\n");
123
}
123
}
124
 
124