WebSVN – HelenOS – Diff – /branches/dd/kernel/test/mm/falloc2.c



{
    int order, run, allocated, i;
    uint8_t val = THREAD->tid % THREADS;
    index_t k;
   
    void **frames =  (void **) malloc(MAX_FRAMES * sizeof(void *), FRAME_ATOMIC);
    if (frames == NULL) {
        if (!sh_quiet)
            printf("Thread #%" PRIu64 " (cpu%u): Unable to allocate frames\n", THREAD->tid, CPU->id);
        atomic_inc(&thread_fail);
        atomic_dec(&thread_count);
        return;
    }
   
    thread_detach(THREAD);
 
    for (run = 0; run < THREAD_RUNS; run++) {
        for (order = 0; order <= MAX_ORDER; order++) {
            if (!sh_quiet)
                printf("Thread #%" PRIu64 " (cpu%u): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
           
            allocated = 0;
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
                frames[allocated] = frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
                if (frames[allocated]) {
                    memsetb(frames[allocated], FRAME_SIZE << order, val);
                    allocated++;
                } else
                    break;
            }
           
            if (!sh_quiet)
                printf("Thread #%" PRIu64 " (cpu%u): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
           
            if (!sh_quiet)
                printf("Thread #%" PRIu64 " (cpu%u): Deallocating ... \n", THREAD->tid, CPU->id);
           
            for (i = 0; i < allocated; i++) {
                for (k = 0; k <= (((index_t) FRAME_SIZE << order) - 1); k++) {
                    if (((uint8_t *) frames[i])[k] != val) {
                        if (!sh_quiet)
                            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);
                        atomic_inc(&thread_fail);
                        goto cleanup;
                    }
                }
                frame_free(KA2PA(frames[i]));
            }
           
            if (!sh_quiet)
                printf("Thread #%" PRIu64 " (cpu%u): Finished run.\n", THREAD->tid, CPU->id);
        }
    }
 
cleanup:   
    free(frames);
   
    if (!sh_quiet)
        printf("Thread #%" PRIu64 " (cpu%u): Exiting\n", THREAD->tid, CPU->id);
    atomic_dec(&thread_count);
}
 
char * test_falloc2(bool quiet)
{

       
    for (i = 0; i < THREADS; i++) {
        thread_t * thrd = thread_create(falloc, NULL, TASK, 0, "falloc", false);
        if (!thrd) {
            if (!quiet)
                printf("Could not create thread %u\n", i);
            break;
        }
        thread_ready(thrd);
    }
   
    while (atomic_get(&thread_count) > 0) {
        if (!quiet)
            printf("Threads left: %ld\n", atomic_get(&thread_count));
        thread_sleep(1);
    }
   
    if (atomic_get(&thread_fail) == 0)
        return NULL;

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;

Subversion Repositories HelenOS

(root)/branches/dd/kernel/test/mm/falloc2.c – Rev 3022 → 4055