Subversion Repositories HelenOS

Rev

Rev 2021 | Rev 2042 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 2021 Rev 2028
Line 23... Line 23...
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
 
28
#include <print.h>
29
#include <print.h>
29
#include <test.h>
30
#include <test.h>
30
#include <mm/page.h>
31
#include <mm/page.h>
31
#include <mm/frame.h>
32
#include <mm/frame.h>
32
#include <mm/slab.h>
33
#include <mm/slab.h>
Line 36... Line 37...
36
#include <debug.h>
37
#include <debug.h>
37
#include <proc/thread.h>
38
#include <proc/thread.h>
38
#include <memstr.h>
39
#include <memstr.h>
39
#include <arch.h>
40
#include <arch.h>
40
 
41
 
41
#ifdef CONFIG_BENCH
-
 
42
#include <arch/cycle.h>
-
 
43
#endif
-
 
44
 
-
 
45
#define MAX_FRAMES 256
42
#define MAX_FRAMES 256
46
#define MAX_ORDER 8
43
#define MAX_ORDER 8
47
 
44
 
48
#define THREAD_RUNS 1
45
#define THREAD_RUNS 1
49
#define THREADS 8
46
#define THREADS 8
50
 
47
 
51
static void falloc(void * arg);
-
 
52
static void failed(void);
-
 
53
 
-
 
54
static atomic_t thread_count;
48
static atomic_t thread_count;
-
 
49
static atomic_t thread_fail;
55
 
50
 
56
void falloc(void * arg)
51
static void falloc(void * arg)
57
{
52
{
58
    int order, run, allocated, i;
53
    int order, run, allocated, i;
59
    uint8_t val = THREAD->tid % THREADS;
54
    uint8_t val = THREAD->tid % THREADS;
60
    index_t k;
55
    index_t k;
61
   
56
   
62
    uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
57
    uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
63
    ASSERT(frames != NULL);
58
    if (frames == NULL) {
-
 
59
        printf("Thread #%d (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);
-
 
60
        atomic_inc(&thread_fail);
-
 
61
        atomic_dec(&thread_count);
-
 
62
        return;
-
 
63
    }
64
   
64
   
65
    thread_detach(THREAD);
65
    thread_detach(THREAD);
66
 
66
 
67
    for (run = 0; run < THREAD_RUNS; run++) {
67
    for (run = 0; run < THREAD_RUNS; run++) {
68
        for (order = 0; order <= MAX_ORDER; order++) {
68
        for (order = 0; order <= MAX_ORDER; order++) {
Line 71... Line 71...
71
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
71
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
72
                frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
72
                frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
73
                if (frames[allocated]) {
73
                if (frames[allocated]) {
74
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
74
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
75
                    allocated++;
75
                    allocated++;
76
                } else {
76
                } else
77
                    break;
77
                    break;
78
                }
78
            }
79
            }
-
 
80
            printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
79
            printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
81
 
80
 
82
            printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
81
            printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
83
            for (i = 0; i < allocated; i++) {
82
            for (i = 0; i < allocated; i++) {
84
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
83
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
85
                    if (((uint8_t *) frames[i])[k] != val) {
84
                    if (((uint8_t *) frames[i])[k] != val) {
86
                        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);
85
                        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);
-
 
86
                        atomic_inc(&thread_fail);
87
                        failed();
87
                        goto cleanup;
88
                    }
88
                    }
89
                }
89
                }
90
                frame_free(KA2PA(frames[i]));
90
                frame_free(KA2PA(frames[i]));
91
            }
91
            }
92
            printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
92
            printf("Thread #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
93
        }
93
        }
94
    }
94
    }
95
   
95
 
-
 
96
cleanup:   
96
    free(frames);
97
    free(frames);
97
    printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
98
    printf("Thread #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);
98
    atomic_dec(&thread_count);
99
    atomic_dec(&thread_count);
99
}
100
}
100
 
101
 
101
 
-
 
102
void failed(void)
102
char * test_falloc2(void)
103
{
103
{
104
    panic("Test failed.\n");
-
 
105
}
-
 
106
 
-
 
107
 
-
 
108
void test_falloc2(void)
-
 
109
{
-
 
110
#ifdef CONFIG_BENCH
-
 
111
    uint64_t t0 = get_cycle();
-
 
112
#endif
-
 
113
    int i;
104
    unsigned int i;
114
 
105
 
115
    atomic_set(&thread_count, THREADS);
106
    atomic_set(&thread_count, THREADS);
-
 
107
    atomic_set(&thread_fail, 0);
116
       
108
       
117
    for (i = 0; i < THREADS; i++) {
109
    for (i = 0; i < THREADS; i++) {
118
        thread_t * thrd;
-
 
119
        thrd = thread_create(falloc, NULL, TASK, 0, "falloc");
110
        thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc");
120
        if (thrd)
111
        if (!thrd) {
-
 
112
            printf("Could not create thread %d\n", i);
-
 
113
            break;
-
 
114
        }
121
            thread_ready(thrd);
115
        thread_ready(thrd);
122
        else
-
 
123
            failed();
-
 
124
    }
116
    }
125
   
117
   
126
    while (thread_count.count)
118
    while (atomic_get(&thread_count) > 0) {
-
 
119
        printf("Threads left: %d\n", atomic_get(&thread_count));
-
 
120
        thread_sleep(1);
127
        ;
121
    }
-
 
122
   
-
 
123
    if (atomic_get(&thread_fail) == 0)
-
 
124
        return NULL;
128
 
125
   
129
    printf("Test passed.\n");
126
    return "Test failed";
130
#ifdef CONFIG_BENCH
-
 
131
    uint64_t dt = get_cycle() - t0;
-
 
132
    printf("Time: %.*d cycles\n", sizeof(dt) * 2, dt);
-
 
133
#endif
-
 
134
}
127
}