WebSVN – Kolibri OS – Diff – /kernel/branches/Kolibri-acpi/core/heap.inc

 ;; Copyright (C) KolibriOS team 2004-2009. All rights reserved. ;;
 ;; Distributed under terms of the GNU General Public License    ;;
 ;;                                                              ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+$Revision: 2138 $
+macro __list_add new, prev, next
+{
+    mov [next+LHEAD.prev], new
+    mov [new+LHEAD.next], next
+    mov [new+LHEAD.prev], prev
+    mov [prev+LHEAD.next], new
+}
+macro list_add new, head
+{
+    mov eax, [head+LHEAD.next]
+    __list_add new, head, eax
+}
+macro list_add_tail new, head
+{
+    mov eax, [head+LHEAD.prev]
+    __list_add new, eax, head
+}
+macro list_del entry
+{
+    mov edx, [entry+list_fd]
+    mov ecx, [entry+list_bk]
+    mov [edx+list_bk], ecx
-$Revision: 2130 $
+    mov [ecx+list_fd], edx
+}
+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
-   .flags       dd ? ;+24
-   .handle      dd ? ;+28
+   .flags       dd ? ;+24
    .handle      dd ? ;+28
+}
 MEM_LIST_OFFSET equ  8
 MEM_BLOCK_SIZE equ 8*4
 block_next   equ MEM_BLOCK.next_block
 block_prev   equ MEM_BLOCK.prev_block
-list_fd      equ MEM_BLOCK.list_fd
+list_fd      equ MEM_BLOCK.list.next
-list_bk      equ MEM_BLOCK.list_bk
+list_bk      equ MEM_BLOCK.list.prev
 block_base   equ MEM_BLOCK.base
 block_size   equ MEM_BLOCK.size
            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_SIZE   free space        FREE_BLOCK
+;HEAP_BASE              heap_descriptors  USED_BLOCK
+;
 align 4
 proc init_kernel_heap
+            mov ecx, 64
-           mov ecx, 64
+            mov edi, mem_block_list
-           mov edi, mem_block_list
+@@:
+            mov eax, edi
-           xor eax, eax
+            stosd
-           cld
+            stosd
-           rep stosd
+            loop @B
-           mov ecx, 512/4
+            mov ecx, 512/4
-           mov edi, mem_block_map
+            mov edi, mem_block_map
-           not eax
+            not eax
-           rep stosd
+            rep stosd
-           mov [mem_block_start], mem_block_map
+            mov [mem_block_start], mem_block_map
-           mov [mem_block_end], mem_block_map+512
+            mov [mem_block_end], mem_block_map+512
-           mov [mem_block_arr], HEAP_BASE
+            mov [mem_block_arr], HEAP_BASE
-           add edi, 0x1000
+            add edi, 0x1000
-           add edx, 0x1000
+            add edx, 0x1000
-           dec ecx
+            dec ecx
-           jnz .l1
+            jnz .l1
-           mov edi, HEAP_BASE
+            mov edi, HEAP_BASE                     ;descriptors
+            mov ebx, HEAP_BASE+MEM_BLOCK_SIZE      ;free space
+            mov ecx, HEAP_BASE+MEM_BLOCK_SIZE*2    ;terminator
            mov ebx, HEAP_BASE+MEM_BLOCK_SIZE
-           xor eax, eax
+            xor eax, eax
-           mov [edi+block_next], ebx
+            mov [edi+block_next], ebx
-           mov [edi+block_prev], eax
+            mov [edi+block_prev], eax
-           mov [edi+list_fd], eax
+            mov [edi+list_fd], eax
-           mov [edi+list_bk], eax
+            mov [edi+list_bk], eax
-           mov [edi+block_base], HEAP_BASE
+            mov [edi+block_base], HEAP_BASE
-           mov [edi+block_size], 4096*MEM_BLOCK_SIZE
+            mov [edi+block_size], 4096*MEM_BLOCK_SIZE
-           mov [edi+block_flags], USED_BLOCK
+            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], 0
+            mov [edi+block_size], 0
+            mov [edi+block_flags], USED_BLOCK
-           mov [ebx+block_next], eax
+            mov [ebx+block_next], ecx
-           mov [ebx+block_prev], eax
+            mov [ebx+block_prev], edi
-           mov [ebx+list_fd], eax
+            mov [ebx+list_fd], eax
-           mov [ebx+list_bk], eax
+            mov [ebx+list_bk], eax
-           mov [ebx+block_flags], FREE_BLOCK
+            mov [ebx+block_flags], FREE_BLOCK
-           mov [mem_block_mask], eax
+            mov [mem_block_mask], eax
-           mov [mem_block_mask+4],0x80000000
+            mov [mem_block_mask+4],0x80000000
+            mov ecx, mem_block_list+63*8
             list_add ebx, ecx
            mov [mem_block_list+63*4], ebx
-           mov byte [mem_block_map], 0xFC
+            mov byte [mem_block_map], 0xFC
-           mov ecx, heap_mutex
+            mov ecx, heap_mutex
-           call mutex_init
+            call mutex_init
            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
+           jmp .find
 align 4
            lea eax,[eax+ebx*8]
            shl eax, 5
            add eax, [mem_block_arr]
            dec [free_blocks]
            ret
 align 4
 free_mem_block:
            mov dword [eax], 0
            mov dword [eax+4], 0
            mov dword [eax+8], 0
 align 4
 proc alloc_kernel_space stdcall, size:dword
+           local block_ind:DWORD
-           local block_ind:DWORD
+           xchg bx, bx
            push ebx
-           push esi
-           push edi
-           mov ecx, heap_mutex
+           push esi
-           call mutex_lock
+           push edi
            mov eax, [size]
            add eax, 4095
            and eax, not 4095
+           mov [size], eax
+           cmp eax, [heap_free]
+           ja .error
-           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
+           jne .error_unlock
            mov [block_ind], ebx   ;index of allocated block
            mov eax, [edi+block_size]
            cmp eax, [size]
            je .m_eq_size
            call alloc_mem_block
-           and eax, eax
-           jz .error
            and eax, eax
-           mov esi, eax           ;esi - splitted block
+           jz .error_unlock
-           mov [esi+block_next], edi
+           mov esi, eax           ;esi - splitted block
            mov eax, [edi+block_prev]
-           mov [esi+block_prev], eax
+           mov [esi+block_next], edi
-           mov [edi+block_prev], esi
+           mov eax, [edi+block_prev]
-           mov [esi+list_fd], 0
+           mov [esi+block_prev], eax
-           mov [esi+list_bk], 0
+           mov [edi+block_prev], esi
-           and eax, eax
-           jz @f
-           mov [eax+block_next], esi
+           mov [esi+list_fd], 0
-@@:
-           mov ebx, [edi+block_base]
-           mov [esi+block_base], ebx
-           mov edx, [size]
+           mov [esi+list_bk], 0
-           mov [esi+block_size], edx
+           mov [eax+block_next], esi
-           add [edi+block_base], edx
-           sub [edi+block_size], edx
+           mov ebx, [edi+block_base]
+           mov [esi+block_base], ebx
-           mov eax, [edi+block_size]
-           shr eax, 12
+           mov edx, [size]
-           sub eax, 1
+           mov [esi+block_size], edx
-           cmp eax, 63
+           add [edi+block_base], edx
-           jna @f
+           sub [edi+block_size], edx
-           mov eax, 63
-@@:
-           cmp eax, [block_ind]
-           je .m_eq_ind
-           remove_from_list edi
            mov ecx, [block_ind]
+           mov eax, [edi+block_size]
+           calc_index eax
-           mov [mem_block_list+ecx*4], edx
+           cmp eax, [block_ind]
+           je .m_eq_ind
            test edx, edx
-           jnz @f
+           list_del edi
            btr [mem_block_mask], ecx
-@@:
+           mov ecx, [block_ind]
-           mov edx, [mem_block_list+eax*4]
+           lea edx, [mem_block_list+ecx*8]
-           mov [edi+list_fd], edx
+           cmp edx, [edx]
-           test edx, edx
+           jnz @f
-           jz @f
+           btr [mem_block_mask], ecx
+@@:
+           bts [mem_block_mask], eax
+           lea edx, [mem_block_list+eax*8]   ;edx= list head
+           list_add edi, edx
+.m_eq_ind:
+           mov ecx, mem_used.fd
+           mov edx, [ecx+list_fd]
+           mov [esi+list_fd], edx
+           mov [esi+list_bk], ecx
+           mov [ecx+list_fd], esi
+           mov [edx+list_bk], esi
+           mov [esi+block_flags], USED_BLOCK
-           mov [edx+list_bk], edi
+           mov ebx, [size]
-@@:
+           sub [heap_free], ebx
            mov [mem_block_list+eax*4], edi
-           bts [mem_block_mask], eax
+;           pushad
-.m_eq_ind:
+;           mov eax, [esi+block_base]
-           mov ecx, mem_used.fd-MEM_LIST_OFFSET
+;           mov ebx, [esi+block_base]
-           mov edx, [ecx+list_fd]
+;           shr ebx, 6
-           mov [esi+list_fd], edx
+;           add eax, ebx
-           mov [esi+list_bk], ecx
+;           shr ebx, 6
-           mov [ecx+list_fd], esi
+;           add eax, ebx
-           mov [edx+list_bk], esi
+;           shr eax, 12
 ;           and eax, 63
-           mov [esi+block_flags], USED_BLOCK
+;           inc [mem_hash_cnt+eax*4]
-           mov ebx, [size]
+;           popad
-           sub [heap_free], ebx
            mov ecx, heap_mutex
            call mutex_unlock
            mov eax, [esi+block_base]
            pop edi
            pop esi
            pop ebx
            ret
 .m_eq_size:
+           list_del edi
+           lea edx, [mem_block_list+ebx*8]
+           cmp edx, [edx]
+           jnz @f
+           btr [mem_block_mask], ebx
+@@:
+           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
-           remove_from_list edi
+           mov [edi+block_flags], USED_BLOCK
-           mov [mem_block_list+ebx*4], edx
+           mov ebx, [size]
-           and edx, edx
+           sub [heap_free], ebx
            jnz @f
-           btr [mem_block_mask], ebx
+;           pushad
-@@:
+;           mov eax, [edi+block_base]
-           mov ecx, mem_used.fd-MEM_LIST_OFFSET
+;           mov ebx, [edi+block_base]
+;           shr ebx, 6
-           mov edx, [ecx+list_fd]
+;           add eax, ebx
-           mov [edi+list_fd], edx
+;           shr ebx, 6
-           mov [edi+list_bk], ecx
+;           add eax, ebx
+;           shr eax, 12
-           mov [ecx+list_fd], edi
+;           and eax, 63
-           mov [edx+list_bk], edi
+;           inc [mem_hash_cnt+eax*4]
 ;           popad
            mov [edi+block_flags], USED_BLOCK
-           mov ebx, [size]
+           mov ecx, heap_mutex
-           sub [heap_free], ebx
+           call mutex_unlock
-           mov ecx, heap_mutex
+           mov eax, [edi+block_base]
-           call mutex_unlock
+           pop edi
+           pop esi
-           mov eax, [edi+block_base]
+           pop ebx
-           pop edi
-           pop esi
-           pop ebx
+           ret
            ret
-.error:
+.error_unlock:
            mov ecx, heap_mutex
            call mutex_unlock
-           xor eax, eax
+.error:
-           pop edi
+           xor eax, eax
-           pop esi
+           pop edi
-           pop ebx
+           pop esi
-           ret
+           pop ebx
-endp
+           ret
 endp
 align 4
-proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
+align 4
+proc free_kernel_space stdcall uses ebx ecx edx esi edi, base:dword
+           xchg bx, bx
+           mov ecx, heap_mutex
+           call mutex_lock
+           mov eax, [base]
+           mov esi, [mem_used.fd]
+@@:
+           cmp esi, mem_used.fd
+           je .fail
-           push ebx
+           cmp [esi+block_base], eax
-           push esi
+           je .found
-           push edi
+           mov esi, [esi+list_fd]
-           mov ecx, heap_mutex
-           call mutex_lock
            jmp @b
-           mov eax, [base]
+.found:
-           mov esi, [mem_used.fd]
+           cmp [esi+block_flags], USED_BLOCK
-@@:
+           jne .fail
            cmp esi, mem_used.fd-MEM_LIST_OFFSET
-           je .fail
-           cmp [esi+block_base], eax
            je .found
-           mov esi, [esi+list_fd]
-           jmp @b
+;           pushad
-.found:
+;           mov eax, [esi+block_base]
+;           mov ebx, [esi+block_base]
+;           shr ebx, 6
+;           add eax, ebx
+;           shr ebx, 6
+;           add eax, ebx
+;           shr eax, 12
+;           and eax, 63
-           cmp [esi+block_flags], USED_BLOCK
+;           dec [mem_hash_cnt+eax*4]
-           jne .fail
+;           popad
            mov eax, [esi+block_size]
-           add [heap_free], eax
-           mov edi, [esi+block_next]
-           test edi, edi
+           add [heap_free], eax
            jz .prev
            mov edi, [esi+block_next]
            cmp [edi+block_flags], FREE_BLOCK
            jne .prev
-           remove_from_free edi
-           mov edx, [edi+block_next]
+           list_del edi
            mov [esi+block_next], edx
-           test edx, edx
+           mov edx, [edi+block_next]
-           jz @f
+           mov [esi+block_next], edx
            mov [edx+block_prev], esi
-           mov [edx+block_prev], esi
+           mov ecx, [edi+block_size]
-@@:
+           add [esi+block_size], ecx
-           mov ecx, [edi+block_size]
-           add [esi+block_size], ecx
+           calc_index ecx
-           mov eax, edi
+           lea edx, [mem_block_list+ecx*8]
-           call free_mem_block
+           cmp edx, [edx]
-.prev:
+           jne @F
-           mov edi, [esi+block_prev]
+           btr [mem_block_mask], ecx
-           test edi, edi
+@@:
-           jz .insert
+           mov eax, edi
-           cmp [edi+block_flags], FREE_BLOCK
-           jne .insert
+           call free_mem_block
-           remove_from_used esi
+.prev:
-           mov edx, [esi+block_next]
-           mov [edi+block_next], edx
-           test edx, edx
-           jz @f
-           mov [edx+block_prev], edi
+           mov edi, [esi+block_prev]
-@@:
-           mov eax, esi
-           call free_mem_block
+           cmp [edi+block_flags], FREE_BLOCK
+           jne .insert
            remove_from_used esi
            mov ecx, [edi+block_size]
-           mov eax, [esi+block_size]
+           mov edx, [esi+block_next]
-           add eax, ecx
+           mov [edi+block_next], edx
-           mov [edi+block_size], eax
+           mov [edx+block_prev], edi
-           calc_index eax
-           calc_index ecx
            cmp eax, ecx
-           je .m_eq
+           mov eax, esi
            call free_mem_block
-           push ecx
-           remove_from_list edi
+           mov ecx, [edi+block_size]
-           pop ecx
+           mov eax, [esi+block_size]
+           add eax, ecx
+           mov [edi+block_size], eax
-           cmp [mem_block_list+ecx*4], edi
-           jne @f
-           mov [mem_block_list+ecx*4], edx
-@@:
-           cmp [mem_block_list+ecx*4], 0
-           jne @f
-           btr [mem_block_mask], ecx
-@@:
-           mov esi, [mem_block_list+eax*4]
-           mov [mem_block_list+eax*4], edi
-           mov [edi+list_fd], esi
-           test esi, esi
-           jz @f
-           mov [esi+list_bk], edi
-@@:
-           bts [mem_block_mask], eax
 .m_eq:
-           mov ecx, heap_mutex
+           calc_index eax                     ;new index
-           call mutex_unlock
+           calc_index ecx                     ;old index
-           xor eax, eax
+           cmp eax, ecx
-           not eax
-           pop edi
-           pop esi
-           pop ebx
+           je .m_eq
            ret
-.insert:
+           push ecx
-           remove_from_used esi
+           list_del edi
            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
            pop edi
            pop esi
 .fail:
            ret
 endp
+align 4
+sys_perf:
+           test ecx, ecx
+           jz .fail
+           mov edi, ecx
+           mov esi, mem_hash_cnt
+           mov ecx, 64
+           rep movsd
+.fail:
+           ret

Subversion Repositories Kolibri OS

(root)/kernel/branches/Kolibri-acpi/core/heap.inc @ 2130 – Rev 2130 → 2138