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



    index_t k;
   
    uintptr_t * frames =  (uintptr_t *) malloc(MAX_FRAMES * sizeof(uintptr_t), FRAME_ATOMIC);
    if (frames == NULL) {
        if (!sh_quiet)
            printf("Thread #%llu (cpu%d): 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 #%llu (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);
           
            allocated = 0;
            for (i = 0; i < (MAX_FRAMES >> order); i++) {
                frames[allocated] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC | FRAME_KA);
                if (frames[allocated]) {

                } else
                    break;
            }
           
            if (!sh_quiet)
                printf("Thread #%llu (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
           
            if (!sh_quiet)
                printf("Thread #%llu (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);
           
            for (i = 0; i < allocated; i++) {
                for (k = 0; k <= ((FRAME_SIZE << order) - 1); k++) {
                    if (((uint8_t *) frames[i])[k] != val) {
                        if (!sh_quiet)
                            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);
                        atomic_inc(&thread_fail);
                        goto cleanup;
                    }
                }
                frame_free(KA2PA(frames[i]));
            }
           
            if (!sh_quiet)
                printf("Thread #%llu (cpu%d): Finished run.\n", THREAD->tid, CPU->id);
        }
    }
 
cleanup:   
    free(frames);
   
    if (!sh_quiet)
        printf("Thread #%llu (cpu%d): Exiting\n", THREAD->tid, CPU->id);
    atomic_dec(&thread_count);
}
 
char * test_falloc2(bool quiet)
{

Rev 2131	Rev 2307
Line 56...	Line 56...
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	uintptr_t * frames = (uintptr_t ) malloc(MAX_FRAMES sizeof(uintptr_t), FRAME_ATOMIC);
59	if (frames == NULL) {	59	if (frames == NULL) {
60	if (!sh_quiet)	60	if (!sh_quiet)
61	printf("Thread #%d (cpu%d): Unable to allocate frames\n", THREAD->tid, CPU->id);	61	printf("Thread #%llu (cpu%d): 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 #%d (cpu%d): Allocating %d frames blocks ... \n", THREAD->tid, CPU->id, 1 << order);	72	printf("Thread #%llu (cpu%d): 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] = (uintptr_t)frame_alloc(order, FRAME_ATOMIC \| FRAME_KA);
77	if (frames[allocated]) {	77	if (frames[allocated]) {
Line 80...	Line 80...
80	} else	80	} else
81	break;	81	break;
82	}	82	}
83		83
84	if (!sh_quiet)	84	if (!sh_quiet)
85	printf("Thread #%d (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);	85	printf("Thread #%llu (cpu%d): %d blocks allocated.\n", THREAD->tid, CPU->id, allocated);
86		86
87	if (!sh_quiet)	87	if (!sh_quiet)
88	printf("Thread #%d (cpu%d): Deallocating ... \n", THREAD->tid, CPU->id);	88	printf("Thread #%llu (cpu%d): 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 <= ((FRAME_SIZE << order) - 1); k++) {	91	for (k = 0; k <= ((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 #%d (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 #%llu (cpu%d): Unexpected data (%d) in block %p offset %#zx\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 #%d (cpu%d): Finished run.\n", THREAD->tid, CPU->id);	103	printf("Thread #%llu (cpu%d): 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 #%d (cpu%d): Exiting\n", THREAD->tid, CPU->id);	111	printf("Thread #%llu (cpu%d): 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	{

Subversion Repositories HelenOS

(root)//branches/rcu/kernel/test/mm/falloc2.c – Rev 2131 → 2307