WebSVN – Kolibri OS – Diff – /kernel/trunk/core/test_malloc.asm


;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;                                                              ;;
;; Copyright (C) KolibriOS team 2009-2011. All rights reserved. ;;
;; Distributed under terms of the GNU General Public License    ;;
;;                                                              ;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; Tests of malloc()/free() from the kernel heap.
; This file is not included in the kernel, it is just test application.
use32
        db      'MENUET01'
        dd      1, start, i_end, mem, mem, 0, 0
 
start:
; Zero-initialize uglobals (as in kernel at boot)
        mov     ecx, (zeroend - zerostart + 3) / 4
        xor     eax, eax
        mov     edi, zerostart
        rep stosd
; Initialize small heap (as in kernel at boot)
        call    init_malloc
; Run tests
        call    run_test1
        call    run_test2
        call    run_test3
; All is OK, return
        or      eax, -1
        int     0x40
 
run_test1:
; basic test
        mov     eax, 1
        call    malloc_with_test
        mov     byte [eax], 0xDD
        mov     esi, eax
        mov     eax, 1
        call    malloc_with_test
        cmp     byte [esi], 0xDD
        jnz     memory_destroyed
        mov     byte [eax], 0xEE
        xchg    eax, esi
        call    free
        cmp     byte [esi], 0xEE
        jnz     memory_destroyed
        xchg    eax, esi
        call    free
        ret
 
run_test2:
        ret
 
run_test3:
; 1024000 times run random operation.
; Randomly select malloc(random size from 1 to 1023)
; or free(random of previously allocated areas)
        mov     edi, 0x12345678
        xor     esi, esi        ; 0 areas allocated
        mov     ebx, 1024000
.loop:
        imul    edi, 1103515245
        add     edi, 12345
        mov     eax, edi
        shr     eax, 16
        test    ebx, 64
        jz      .prefer_free
.prefer_malloc:
        test    eax, 3
        jz      .free
        jmp     @f
.prefer_free:
        test    eax, 3
        jnz     .free
@@:
        shr     eax, 2
        and     eax, 1023
        jz      .loop
        push    ebx
        push    eax
;       mov     ecx, [saved_state_num]
;       mov     [saved_state+ecx*8], eax
        call    malloc_with_test
;       mov     ecx, [saved_state_num]
;       mov     [saved_state+ecx*8+4], eax
;       inc     [saved_state_num]
        pop     ecx
        pop     ebx
        inc     esi
        push    ecx eax
        push    edi
        mov     edi, eax
        mov     eax, esi
        rep stosb
        pop     edi
        jmp     .common
.free:
        test    esi, esi
        jz      .loop
        xor     edx, edx
        div     esi
        sub     edx, esi
        neg     edx
        dec     edx
        mov     eax, [esp+edx*8]
;       mov     ecx, [saved_state_num]
;       mov     [saved_state+ecx*8], -1
;       mov     [saved_state+ecx*8+4], eax
;       inc     [saved_state_num]
        mov     ecx, [esp+edx*8+4]
        push    edi eax
        mov     edi, eax
        mov     al, [edi]
        repz scasb
        jnz     memory_destroyed
        pop     eax edi
        push    ebx edx
        call    free
        pop     edx ebx
        dec     esi
        pop     eax ecx
        push    edi
        lea     edi, [esp+4]
@@:
        dec     edx
        js      @f
        xchg    eax, [edi]
        xchg    ecx, [edi+4]
        add     edi, 8
        jmp     @b
@@:
        pop     edi
.common:
        dec     ebx
        jnz     .loop
@@:
        dec     esi
        js      @f
        pop     eax ecx
        call    free
        jmp     @b
@@:
        ret
 
malloc_with_test:
; calls malloc() and checks returned value
        call    malloc
        test    eax, eax
        jz      generic_malloc_fail
        call    check_mutex
        call    check_range
        ret
 
; Stubs for kernel procedures used by heap code
wait_mutex:
        inc     dword [ebx]
        ret
 
kernel_alloc:
        cmp     dword [esp+4], bufsize
        jnz     error1
        mov     eax, buffer
        ret     4
 
macro $Revision [args]
{
}
 
; Error handlers
error1:
        mov     eax, 1
        jmp     error_with_code
 
generic_malloc_fail:
        mov     eax, 2
        jmp     error_with_code
 
check_mutex:
        cmp     [mst.mutex], 0
        jnz     @f
        ret
@@:
        mov     eax, 3
        jmp     error_with_code
 
check_range:
        cmp     eax, buffer
        jb      @f
        cmp     eax, buffer+bufsize
        jae     @f
        ret
@@:
        mov     eax, 4
        jmp     error_with_code
 
memory_destroyed:
        mov     eax, 5
        jmp     error_with_code
 
error_with_code:
        mov     edx, saved_state_num
; eax = error code
; 1 signals error in testing code (wrong bufsize)
; 2 = malloc() returned NULL
; 3 = mutex not released
; 4 = weird returned value from malloc()
; 5 = memory destroyed by malloc() or free()
        int3    ; simplest way to report error
        jmp     $-1     ; just in case
 
; Include main heap code
include '../proc32.inc'
include '../const.inc'
include 'malloc.inc'
 
i_end:
 
align 4
zerostart:
mst     MEM_STATE
 
align 16
bufsize = 0x40000       ; change if malloc.inc changes
buffer  rb      bufsize
zeroend:
 
saved_state_num dd      ?
saved_state     rd      0x10000
 
align 4
        rb      0x10000 ; for stack
mem:

Rev 2288	Rev 2455
-		1	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		2	;; ;;
-		3	;; Copyright (C) KolibriOS team 2009-2011. All rights reserved. ;;
-		4	;; Distributed under terms of the GNU General Public License ;;
-		5	;; ;;
-		6	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-		7
1	; Tests of malloc()/free() from the kernel heap.	8	; Tests of malloc()/free() from the kernel heap.
2	; This file is not included in the kernel, it is just test application.	9	; This file is not included in the kernel, it is just test application.
3	use32	10	use32
4	db 'MENUET01'	11	db 'MENUET01'
5	dd 1, start, i_end, mem, mem, 0, 0	12	dd 1, start, i_end, mem, mem, 0, 0
6		13
7	start:	14	start:
8	; Zero-initialize uglobals (as in kernel at boot)	15	; Zero-initialize uglobals (as in kernel at boot)
9	mov ecx, (zeroend - zerostart + 3) / 4	16	mov ecx, (zeroend - zerostart + 3) / 4
10	xor eax, eax	17	xor eax, eax
11	mov edi, zerostart	18	mov edi, zerostart
12	rep stosd	19	rep stosd
13	; Initialize small heap (as in kernel at boot)	20	; Initialize small heap (as in kernel at boot)
14	call init_malloc	21	call init_malloc
15	; Run tests	22	; Run tests
16	call run_test1	23	call run_test1
17	call run_test2	24	call run_test2
18	call run_test3	25	call run_test3
19	; All is OK, return	26	; All is OK, return
20	or eax, -1	27	or eax, -1
21	int 0x40	28	int 0x40
22		29
23	run_test1:	30	run_test1:
24	; basic test	31	; basic test
25	mov eax, 1	32	mov eax, 1
26	call malloc_with_test	33	call malloc_with_test
27	mov byte [eax], 0xDD	34	mov byte [eax], 0xDD
28	mov esi, eax	35	mov esi, eax
29	mov eax, 1	36	mov eax, 1
30	call malloc_with_test	37	call malloc_with_test
31	cmp byte [esi], 0xDD	38	cmp byte [esi], 0xDD
32	jnz memory_destroyed	39	jnz memory_destroyed
33	mov byte [eax], 0xEE	40	mov byte [eax], 0xEE
34	xchg eax, esi	41	xchg eax, esi
35	call free	42	call free
36	cmp byte [esi], 0xEE	43	cmp byte [esi], 0xEE
37	jnz memory_destroyed	44	jnz memory_destroyed
38	xchg eax, esi	45	xchg eax, esi
39	call free	46	call free
40	ret	47	ret
41		48
42	run_test2:	49	run_test2:
43	ret	50	ret
44		51
45	run_test3:	52	run_test3:
46	; 1024000 times run random operation.	53	; 1024000 times run random operation.
47	; Randomly select malloc(random size from 1 to 1023)	54	; Randomly select malloc(random size from 1 to 1023)
48	; or free(random of previously allocated areas)	55	; or free(random of previously allocated areas)
49	mov edi, 0x12345678	56	mov edi, 0x12345678
50	xor esi, esi ; 0 areas allocated	57	xor esi, esi ; 0 areas allocated
51	mov ebx, 1024000	58	mov ebx, 1024000
52	.loop:	59	.loop:
53	imul edi, 1103515245	60	imul edi, 1103515245
54	add edi, 12345	61	add edi, 12345
55	mov eax, edi	62	mov eax, edi
56	shr eax, 16	63	shr eax, 16
57	test ebx, 64	64	test ebx, 64
58	jz .prefer_free	65	jz .prefer_free
59	.prefer_malloc:	66	.prefer_malloc:
60	test eax, 3	67	test eax, 3
61	jz .free	68	jz .free
62	jmp @f	69	jmp @f
63	.prefer_free:	70	.prefer_free:
64	test eax, 3	71	test eax, 3
65	jnz .free	72	jnz .free
66	@@:	73	@@:
67	shr eax, 2	74	shr eax, 2
68	and eax, 1023	75	and eax, 1023
69	jz .loop	76	jz .loop
70	push ebx	77	push ebx
71	push eax	78	push eax
72	; mov ecx, [saved_state_num]	79	; mov ecx, [saved_state_num]
73	; mov [saved_state+ecx*8], eax	80	; mov [saved_state+ecx*8], eax
74	call malloc_with_test	81	call malloc_with_test
75	; mov ecx, [saved_state_num]	82	; mov ecx, [saved_state_num]
76	; mov [saved_state+ecx*8+4], eax	83	; mov [saved_state+ecx*8+4], eax
77	; inc [saved_state_num]	84	; inc [saved_state_num]
78	pop ecx	85	pop ecx
79	pop ebx	86	pop ebx
80	inc esi	87	inc esi
81	push ecx eax	88	push ecx eax
82	push edi	89	push edi
83	mov edi, eax	90	mov edi, eax
84	mov eax, esi	91	mov eax, esi
85	rep stosb	92	rep stosb
86	pop edi	93	pop edi
87	jmp .common	94	jmp .common
88	.free:	95	.free:
89	test esi, esi	96	test esi, esi
90	jz .loop	97	jz .loop
91	xor edx, edx	98	xor edx, edx
92	div esi	99	div esi
93	sub edx, esi	100	sub edx, esi
94	neg edx	101	neg edx
95	dec edx	102	dec edx
96	mov eax, [esp+edx*8]	103	mov eax, [esp+edx*8]
97	; mov ecx, [saved_state_num]	104	; mov ecx, [saved_state_num]
98	; mov [saved_state+ecx*8], -1	105	; mov [saved_state+ecx*8], -1
99	; mov [saved_state+ecx*8+4], eax	106	; mov [saved_state+ecx*8+4], eax
100	; inc [saved_state_num]	107	; inc [saved_state_num]
101	mov ecx, [esp+edx*8+4]	108	mov ecx, [esp+edx*8+4]
102	push edi eax	109	push edi eax
103	mov edi, eax	110	mov edi, eax
104	mov al, [edi]	111	mov al, [edi]
105	repz scasb	112	repz scasb
106	jnz memory_destroyed	113	jnz memory_destroyed
107	pop eax edi	114	pop eax edi
108	push ebx edx	115	push ebx edx
109	call free	116	call free
110	pop edx ebx	117	pop edx ebx
111	dec esi	118	dec esi
112	pop eax ecx	119	pop eax ecx
113	push edi	120	push edi
114	lea edi, [esp+4]	121	lea edi, [esp+4]
115	@@:	122	@@:
116	dec edx	123	dec edx
117	js @f	124	js @f
118	xchg eax, [edi]	125	xchg eax, [edi]
119	xchg ecx, [edi+4]	126	xchg ecx, [edi+4]
120	add edi, 8	127	add edi, 8
121	jmp @b	128	jmp @b
122	@@:	129	@@:
123	pop edi	130	pop edi
124	.common:	131	.common:
125	dec ebx	132	dec ebx
126	jnz .loop	133	jnz .loop
127	@@:	134	@@:
128	dec esi	135	dec esi
129	js @f	136	js @f
130	pop eax ecx	137	pop eax ecx
131	call free	138	call free
132	jmp @b	139	jmp @b
133	@@:	140	@@:
134	ret	141	ret
135		142
136	malloc_with_test:	143	malloc_with_test:
137	; calls malloc() and checks returned value	144	; calls malloc() and checks returned value
138	call malloc	145	call malloc
139	test eax, eax	146	test eax, eax
140	jz generic_malloc_fail	147	jz generic_malloc_fail
141	call check_mutex	148	call check_mutex
142	call check_range	149	call check_range
143	ret	150	ret
144		151
145	; Stubs for kernel procedures used by heap code	152	; Stubs for kernel procedures used by heap code
146	wait_mutex:	153	wait_mutex:
147	inc dword [ebx]	154	inc dword [ebx]
148	ret	155	ret
149		156
150	kernel_alloc:	157	kernel_alloc:
151	cmp dword [esp+4], bufsize	158	cmp dword [esp+4], bufsize
152	jnz error1	159	jnz error1
153	mov eax, buffer	160	mov eax, buffer
154	ret 4	161	ret 4
155		162
156	macro $Revision [args]	163	macro $Revision [args]
157	{	164	{
158	}	165	}
159		166
160	; Error handlers	167	; Error handlers
161	error1:	168	error1:
162	mov eax, 1	169	mov eax, 1
163	jmp error_with_code	170	jmp error_with_code
164		171
165	generic_malloc_fail:	172	generic_malloc_fail:
166	mov eax, 2	173	mov eax, 2
167	jmp error_with_code	174	jmp error_with_code
168		175
169	check_mutex:	176	check_mutex:
170	cmp [mst.mutex], 0	177	cmp [mst.mutex], 0
171	jnz @f	178	jnz @f
172	ret	179	ret
173	@@:	180	@@:
174	mov eax, 3	181	mov eax, 3
175	jmp error_with_code	182	jmp error_with_code
176		183
177	check_range:	184	check_range:
178	cmp eax, buffer	185	cmp eax, buffer
179	jb @f	186	jb @f
180	cmp eax, buffer+bufsize	187	cmp eax, buffer+bufsize
181	jae @f	188	jae @f
182	ret	189	ret
183	@@:	190	@@:
184	mov eax, 4	191	mov eax, 4
185	jmp error_with_code	192	jmp error_with_code
186		193
187	memory_destroyed:	194	memory_destroyed:
188	mov eax, 5	195	mov eax, 5
189	jmp error_with_code	196	jmp error_with_code
190		197
191	error_with_code:	198	error_with_code:
192	mov edx, saved_state_num	199	mov edx, saved_state_num
193	; eax = error code	200	; eax = error code
194	; 1 signals error in testing code (wrong bufsize)	201	; 1 signals error in testing code (wrong bufsize)
195	; 2 = malloc() returned NULL	202	; 2 = malloc() returned NULL
196	; 3 = mutex not released	203	; 3 = mutex not released
197	; 4 = weird returned value from malloc()	204	; 4 = weird returned value from malloc()
198	; 5 = memory destroyed by malloc() or free()	205	; 5 = memory destroyed by malloc() or free()
199	int3 ; simplest way to report error	206	int3 ; simplest way to report error
200	jmp $-1 ; just in case	207	jmp $-1 ; just in case
201		208
202	; Include main heap code	209	; Include main heap code
203	include '../proc32.inc'	210	include '../proc32.inc'
204	include '../const.inc'	211	include '../const.inc'
205	include 'malloc.inc'	212	include 'malloc.inc'
206		213
207	i_end:	214	i_end:
208		215
209	align 4	216	align 4
210	zerostart:	217	zerostart:
211	mst MEM_STATE	218	mst MEM_STATE
212		219
213	align 16	220	align 16
214	bufsize = 0x40000 ; change if malloc.inc changes	221	bufsize = 0x40000 ; change if malloc.inc changes
215	buffer rb bufsize	222	buffer rb bufsize
216	zeroend:	223	zeroend:
217		224
218	saved_state_num dd ?	225	saved_state_num dd ?
219	saved_state rd 0x10000	226	saved_state rd 0x10000
220		227
221	align 4	228	align 4
222	rb 0x10000 ; for stack	229	rb 0x10000 ; for stack
223	mem:	230	mem:

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/test_malloc.asm – Rev 2288 → 2455