WebSVN – Kolibri OS – Diff – /kernel/trunk/core/heap.inc

 ;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-$Revision: 2129 $
+$Revision: 2154 $
+struc MEM_BLOCK
+{
-struc MEM_BLOCK
-{  .next_block  dd ?
-   .prev_block  dd ? ;+4
+   .list        LHEAD
-   .list_fd     dd ? ;+8
+   .next_block  dd ? ;+8
-   .list_bk     dd ? ;+12
+   .prev_block  dd ? ;+4
    .base        dd ? ;+16
+   .size        dd ? ;+20
-   .size        dd ? ;+20
+   .flags       dd ? ;+24
-   .flags       dd ? ;+24
    .handle      dd ? ;+28
    .sizeof:
+}
 MEM_LIST_OFFSET equ  8
 FREE_BLOCK      equ  4
 USED_BLOCK      equ  8
-DONT_FREE_BLOCK equ  10h
 DONT_FREE_BLOCK equ  10h
 virtual at 0
-  MEM_BLOCK MEM_BLOCK
+virtual at 0
-end virtual
+  MEM_BLOCK MEM_BLOCK
 end virtual
 MEM_BLOCK_SIZE equ 8*4
 block_next   equ MEM_BLOCK.next_block
            jna @f
            mov op, 63
 @@:
+}
-macro remove_from_list op
-{          mov edx, [op+list_fd]
-           mov ecx, [op+list_bk]
-           test edx, edx
-           jz @f
-           mov [edx+list_bk], ecx
-@@:
-           test ecx, ecx
-           jz @f
-           mov [ecx+list_fd], edx
-@@:
-           mov [op+list_fd],0
-           mov [op+list_bk],0
-}
-macro remove_from_free op
-{
-           remove_from_list op
-           mov eax, [op+block_size]
-           calc_index eax
-           cmp [mem_block_list+eax*4], op
-           jne @f
-           mov [mem_block_list+eax*4], edx
-@@:
-           cmp [mem_block_list+eax*4], 0
-           jne @f
-           btr [mem_block_mask], eax
-@@:
-}
 macro remove_from_used op
+{
            mov edx, [op+list_fd]
            mov ecx, [op+list_bk]
            mov [edx+list_bk], ecx
            mov [ecx+list_fd], edx
            mov [op+list_fd], 0
            mov [op+list_bk], 0
+}
+;Initial heap state
+;
+;+heap_size               terminator        USED_BLOCK
+;+4096*MEM_BLOCK.sizeof   free space        FREE_BLOCK
+;HEAP_BASE                heap_descriptors  USED_BLOCK
+;
 align 4
 proc init_kernel_heap
-           mov ecx, 64
-           mov edi, mem_block_list
-           xor eax, eax
-           cld
+           mov ecx, 64
-           rep stosd
+           mov edi, mem_block_list
-           mov ecx, 512/4
+@@:
-           mov edi, mem_block_map
-           not eax
-           rep stosd
+            mov eax, edi
-           mov [mem_block_start], mem_block_map
+            stosd
-           mov [mem_block_end], mem_block_map+512
+            stosd
-           mov [mem_block_arr], HEAP_BASE
+            loop @B
-           mov eax, mem_used.fd-MEM_LIST_OFFSET
+            mov eax, mem_used.fd
            add edi, 0x1000
            add edx, 0x1000
            dec ecx
            jnz .l1
-           mov edi, HEAP_BASE
+            mov edi, HEAP_BASE                     ;descriptors
+            mov ebx, HEAP_BASE+MEM_BLOCK.sizeof      ;free space
+            mov ecx, HEAP_BASE+MEM_BLOCK.sizeof*2    ;terminator
            mov ebx, HEAP_BASE+MEM_BLOCK_SIZE
            xor eax, eax
            mov [edi+block_next], ebx
            mov [edi+block_prev], eax
            mov [edi+list_fd], eax
            mov [edi+list_bk], eax
            mov [edi+block_base], HEAP_BASE
+            mov [edi+block_size], 4096*MEM_BLOCK.sizeof
+           mov [edi+block_flags], USED_BLOCK
+            mov [ecx+block_next], eax
+            mov [ecx+block_prev], ebx
+            mov [edi+list_fd], eax
+            mov [edi+list_bk], eax
+            mov [edi+block_base], eax
-           mov [edi+block_size], 4096*MEM_BLOCK_SIZE
+            mov [edi+block_size], eax
-           mov [edi+block_flags], USED_BLOCK
+            mov [edi+block_flags], USED_BLOCK
-           mov [ebx+block_next], eax
-           mov [ebx+block_prev], eax
-           mov [ebx+list_fd], eax
+            mov [ebx+block_next], ecx
-           mov [ebx+list_bk], eax
+            mov [ebx+block_prev], edi
-           mov [ebx+block_base], HEAP_BASE+4096*MEM_BLOCK_SIZE
+            mov [ebx+block_base], HEAP_BASE+4096*MEM_BLOCK.sizeof
            mov ecx, [pg_data.kernel_pages]
            shl ecx, 12
-           sub ecx, HEAP_BASE-OS_BASE+4096*MEM_BLOCK_SIZE
+            sub ecx, HEAP_BASE-OS_BASE+4096*MEM_BLOCK.sizeof
            mov [heap_size], ecx
            mov [heap_free], ecx
            mov [ebx+block_size], ecx
            mov [ebx+block_flags], FREE_BLOCK
+           mov [mem_block_mask], eax
+           mov [mem_block_mask+4],0x80000000
+            mov ecx, mem_block_list+63*8
+            list_add ebx, ecx
+            mov ecx, 4096-3-1
+            mov eax, HEAP_BASE+MEM_BLOCK.sizeof*4
+            mov [next_memblock], HEAP_BASE+MEM_BLOCK.sizeof*3
+@@:
+            mov [eax-MEM_BLOCK.sizeof], eax
+            add eax, MEM_BLOCK.sizeof
-           mov [mem_block_mask], eax
+            loop @B
            mov [mem_block_mask+4],0x80000000
+            mov [eax-MEM_BLOCK.sizeof], dword 0
-           mov [mem_block_list+63*4], ebx
            mov byte [mem_block_map], 0xFC
            mov ecx, heap_mutex
            call mutex_init
-           mov [heap_blocks], 4095
+            mov [heap_blocks], 4094
            and edx, [esi]
 .find:
            bsf edi, edx
            jz .high_mask
            add ebx, edi
-           mov edi, [mem_block_list+ebx*4]
+           lea ecx, [mem_block_list+ebx*8]
+           mov edi, ecx
-.check_size:
+.next:
+           mov edi, [edi+list_fd]
+           cmp edi, ecx
+           je .err
            cmp eax, [edi+block_size]
            ja .next
            ret
+.err:
+           xor edi, edi
+           ret
 .high_mask:
            add esi, 4
            cmp esi, mem_block_mask+8
            jae .err
            add ebx, 32
            mov edx, [esi]
-           jmp .find
-.next:
-           mov edi, [edi+list_fd]
-           test edi, edi
-           jnz .check_size
-.err:
-           xor edi, edi
-           ret
-align 4
-alloc_mem_block:
-           mov ebx, [mem_block_start]
-           mov ecx, [mem_block_end]
-.l1:
-           bsf eax,[ebx];
-           jnz found
-           add ebx,4
-           cmp ebx, ecx
-           jb .l1
-           xor eax,eax
-           ret
-found:
-           btr [ebx], eax
-           mov [mem_block_start],ebx
-           sub ebx, mem_block_map
-           lea eax,[eax+ebx*8]
-           shl eax, 5
-           add eax, [mem_block_arr]
+           jmp .find
            dec [free_blocks]
-           ret
-align 4
-free_mem_block:
+align 4
-           mov dword [eax], 0
-           mov dword [eax+4], 0
-           mov dword [eax+8], 0
-           mov dword [eax+12], 0
-           mov dword [eax+16], 0
-;           mov dword [eax+20], 0
-           mov dword [eax+24], 0
+free_mem_block:
-           mov dword [eax+28], 0
+           mov ebx, [next_memblock]
+           mov [eax], ebx
-           sub eax, [mem_block_arr]
+           mov [next_memblock], eax
+           xor ebx, ebx
+           mov dword [eax+4], ebx
+           mov dword [eax+8], ebx
+           mov dword [eax+12], ebx
-           shr eax, 5
+           mov dword [eax+16], ebx
-           mov ebx, mem_block_map
-           bts [ebx], eax
-           inc [free_blocks]
-           shr eax, 3
-           and eax, not 3
-           add eax, ebx
-           cmp [mem_block_start], eax
-           ja @f
-           ret
-@@:
-           mov [mem_block_start], eax
+;           mov dword [eax+20], 0     ;don't clear block size
-	   ret
+           mov dword [eax+24], ebx
-.err:
+           mov dword [eax+28], ebx
-           xor eax, eax
+           inc [free_blocks]
 	   ret
 align 4
-proc alloc_kernel_space stdcall, size:dword
-           local block_ind:DWORD
-           push ebx
+proc alloc_kernel_space stdcall, size:dword
-           push esi
+           local block_ind:DWORD
            push edi
            push ebx
-           mov ecx, heap_mutex
+           push esi
-           call mutex_lock
+           push edi
+           mov eax, [size]
+           add eax, 4095
+           and eax, not 4095
+           mov [size], eax
-           mov eax, [size]
+           cmp eax, [heap_free]
-           add eax, 4095
+           ja .error
            and eax, not 4095
-           mov [size], eax
+           mov ecx, heap_mutex
            call mutex_lock
            cmp eax, [heap_free]
-           ja .error
+           mov eax, [size]
            call get_small_block ; eax
            test edi, edi
-           jz .error
+           jz .error_unlock
+           cmp [edi+block_flags], FREE_BLOCK
+           jne .error_unlock
            cmp [edi+block_flags], FREE_BLOCK
-           jne .error
+           mov [block_ind], ebx   ;index of allocated block
-           mov [block_ind], ebx   ;index of allocated block
+           mov eax, [edi+block_size]
            cmp eax, [size]
-           mov eax, [edi+block_size]
+           je .m_eq_size
-           cmp eax, [size]
-           je .m_eq_size
-           call alloc_mem_block
+           mov esi, [next_memblock]     ;new memory block
-           and eax, eax
+           test esi, esi
-           jz .error
+           jz .error_unlock
-           mov esi, eax           ;esi - splitted block
+           dec [free_blocks]
            mov eax, [esi]
-           mov [esi+block_next], edi
+           mov [next_memblock], eax
            mov eax, [edi+block_prev]
-           mov [esi+block_prev], eax
-           mov [edi+block_prev], esi
-           mov [esi+list_fd], 0
+           mov [esi+block_next], edi
-           mov [esi+list_bk], 0
-           and eax, eax
-           jz @f
-           mov [eax+block_next], esi
+           mov eax, [edi+block_prev]
-@@:
+           mov [esi+block_prev], eax
-           mov ebx, [edi+block_base]
+           mov [edi+block_prev], esi
-           mov [esi+block_base], ebx
+           mov [esi+list_fd], 0
-           mov edx, [size]
+           mov [esi+list_bk], 0
-           mov [esi+block_size], edx
-           add [edi+block_base], edx
+           mov [eax+block_next], esi
            sub [edi+block_size], edx
            mov ebx, [edi+block_base]
-           mov eax, [edi+block_size]
+           mov [esi+block_base], ebx
-           shr eax, 12
-           sub eax, 1
-           cmp eax, 63
-           jna @f
-           mov eax, 63
-@@:
-           cmp eax, [block_ind]
-           je .m_eq_ind
+           mov edx, [size]
+           mov [esi+block_size], edx
+           add [edi+block_base], edx
            sub [edi+block_size], edx
-           remove_from_list edi
            mov eax, [edi+block_size]
-           mov ecx, [block_ind]
+           calc_index eax
-           mov [mem_block_list+ecx*4], edx
+           cmp eax, [block_ind]
            je .m_eq_ind
            test edx, edx
            pop edi
            pop esi
            pop ebx
            ret
 .m_eq_size:
-           remove_from_list edi
+           list_del edi
-           mov [mem_block_list+ebx*4], edx
+           lea edx, [mem_block_list+ebx*8]
-           and edx, edx
+           cmp edx, [edx]
            jnz @f
            btr [mem_block_mask], ebx
 @@:
-           mov ecx, mem_used.fd-MEM_LIST_OFFSET
+           mov ecx, mem_used.fd
            mov edx, [ecx+list_fd]
            mov [edi+list_fd], edx
            mov [edi+list_bk], ecx
            mov [ecx+list_fd], edi
            mov [edx+list_bk], edi
            mov eax, [edi+block_base]
            pop edi
            pop esi
            pop ebx
            ret
-.error:
+.error_unlock:
            mov ecx, heap_mutex
            call mutex_unlock
+.error:
            xor eax, eax
            pop edi
            pop esi
            pop ebx
            ret
 endp
 align 4
-proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
-           push ebx
-           push esi
-           push edi
+proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
            mov ecx, heap_mutex
            call mutex_lock
            mov eax, [base]
            mov esi, [mem_used.fd]
 @@:
-           cmp esi, mem_used.fd-MEM_LIST_OFFSET
+           cmp esi, mem_used.fd
            je .fail
            mov eax, [esi+block_size]
            add [heap_free], eax
-           mov edi, [esi+block_next]
-           test edi, edi
            jz .prev
            mov edi, [esi+block_next]
            cmp [edi+block_flags], FREE_BLOCK
            jne .prev
-           remove_from_free edi
-           mov edx, [edi+block_next]
-           mov [esi+block_next], edx
+           list_del edi
-           test edx, edx
            jz @f
            mov edx, [edi+block_next]
+           mov [esi+block_next], edx
+           mov [edx+block_prev], esi
+           mov ecx, [edi+block_size]
+           add [esi+block_size], ecx
+           calc_index ecx
-           mov [edx+block_prev], esi
+           lea edx, [mem_block_list+ecx*8]
-@@:
+           cmp edx, [edx]
-           mov ecx, [edi+block_size]
+           jne @F
-           add [esi+block_size], ecx
+           btr [mem_block_mask], ecx
-           mov eax, edi
-           call free_mem_block
-.prev:
+@@:
-           mov edi, [esi+block_prev]
+           mov eax, edi
-           test edi, edi
+           call free_mem_block
-           jz .insert
+.prev:
            mov edi, [esi+block_prev]
-           cmp [edi+block_flags], FREE_BLOCK
-           jne .insert
            cmp [edi+block_flags], FREE_BLOCK
-           remove_from_used esi
+           jne .insert
-           mov edx, [esi+block_next]
+           remove_from_used esi
            mov [edi+block_next], edx
-           test edx, edx
+           mov edx, [esi+block_next]
-           jz @f
+           mov [edi+block_next], edx
            mov [edx+block_prev], edi
-@@:
            mov eax, esi
            call free_mem_block
            mov ecx, [edi+block_size]
            mov eax, [esi+block_size]
            add eax, ecx
            mov [edi+block_size], eax
-           calc_index eax
-           calc_index ecx
-           cmp eax, ecx
-           je .m_eq
+           calc_index eax                     ;new index
            calc_index ecx                     ;old index
-           push ecx
-           remove_from_list edi
-           pop ecx
-           cmp [mem_block_list+ecx*4], edi
-           jne @f
+           cmp eax, ecx
-           mov [mem_block_list+ecx*4], edx
-@@:
-           cmp [mem_block_list+ecx*4], 0
+           je .m_eq
+           push ecx
-           jne @f
+           list_del edi
-           btr [mem_block_mask], ecx
+           pop ecx
 @@:
-           mov esi, [mem_block_list+eax*4]
+           lea edx, [mem_block_list+ecx*8]
-           mov [mem_block_list+eax*4], edi
+           cmp edx, [edx]
-           mov [edi+list_fd], esi
-           test esi, esi
-           jz @f
-           mov [esi+list_bk], edi
+           jne .add_block
-@@:
+           btr [mem_block_mask], ecx
-           bts [mem_block_mask], eax
+.add_block:
-.m_eq:
+           bts [mem_block_mask], eax
-           mov ecx, heap_mutex
+           lea edx, [mem_block_list+eax*8]
-           call mutex_unlock
+           list_add edi, edx
+.m_eq:
+           mov ecx, heap_mutex
-           xor eax, eax
-           not eax
-           pop edi
-           pop esi
-           pop ebx
-           ret
-.insert:
-           remove_from_used esi
-           mov eax, [esi+block_size]
-           calc_index eax
-           mov edi, [mem_block_list+eax*4]
-           mov [mem_block_list+eax*4], esi
-           mov [esi+list_fd], edi
-           test edi, edi
-           jz @f
-           mov [edi+list_bk], esi
+           call mutex_unlock
-@@:
+           xor eax, eax
-           bts [mem_block_mask], eax
+           not eax
-           mov [esi+block_flags],FREE_BLOCK
+           ret
-           mov ecx, heap_mutex
-           call mutex_unlock
-           xor eax, eax
-           not eax
+.insert:
-           pop edi
+           remove_from_used esi
-           pop esi
+           mov [esi+block_flags], FREE_BLOCK
-           pop ebx
+           mov eax, [esi+block_size]
            call mutex_lock
            mov eax, [base]
            mov esi, [mem_used.fd]
 @@:
-           cmp esi, mem_used.fd-MEM_LIST_OFFSET
+           cmp esi, mem_used.fd
            je .fail
            cmp [esi+block_base], eax

Subversion Repositories Kolibri OS

(root)/kernel/trunk/core/heap.inc – Rev 2129 → 2154