WebSVN – Kolibri OS – Diff – /kernel/branches/flat_kernel/core/sched.inc

 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; IRQ0 HANDLER (TIMER INTERRUPT) ;;
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 align 32
 irq0:
         pushfd
         pushad
         mov   ax, app_data  ;
         mov   ds, ax
         mov   es, ax
         inc   dword [timer_ticks]
         mov   eax, [timer_ticks]
         call  playNote           ; <<<--- Speaker driver
         cmp   eax,[next_usage_update]
         jb    .nocounter
         add   eax,100
         mov   [next_usage_update],eax
         call  updatecputimes
 .nocounter:
         cmp   [DONT_SWITCH], byte 1
         jne   .change_task
         mov   al,0x20   ; send End Of Interrupt signal
         mov   dx,0x20
         out   dx,al
         mov   [DONT_SWITCH], byte 0
         popad
         popfd
         iretd
 .change_task:
         call  update_counters
         call  find_next_task
         mov   ecx, eax
         mov   al,0x20   ; send End Of Interrupt signal
         mov   dx,0x20
         out   dx,al
 	test  ecx, ecx  ; if there is only one running process
         jnz   .return
         call  do_change_task
 .return:
         popad
         popfd
         iretd
 align 4
 change_task:
         pushfd
         cli
         pushad
         call  update_counters
 if 0
 ; \begin{Mario79}
         cmp     [dma_task_switched], 1
         jne     .find_next_task
         mov     [dma_task_switched], 0
         mov     ebx, [dma_process]
         cmp     [CURRENT_TASK], ebx
         je      .return
         mov     edi, [dma_slot_ptr]
         mov     [CURRENT_TASK], ebx
         mov     [TASK_BASE], edi
         jmp     @f
 .find_next_task:
 ; \end{Mario79}
 end if
         call  find_next_task
         test  eax, eax    ; the same task -> skip switch
         jnz    .return
 @@:
         mov   [DONT_SWITCH],byte 1
         call  do_change_task
 .return:
         popad
         popfd
         ret
 uglobal
    align 4
    far_jump:
     .offs dd ?
     .sel  dw ?
    context_counter     dd ? ;noname & halyavin
    next_usage_update   dd ?
    timer_ticks         dd ?
    prev_slot           dd ?
    event_sched         dd ?
 endg
 update_counters:
         mov   edi, [TASK_BASE]
         mov   ebx, [edi+TASKDATA.counter_add] ; time stamp counter add
         rdtsc
         sub   eax, ebx
         add   eax, [edi+TASKDATA.counter_sum] ; counter sum
         mov   [edi+TASKDATA.counter_sum], eax
 ret
 ; Find next task to execute
 ; result: ebx = number of the selected task
 ;         eax = 1  if the task is the same
 ;         edi = address of the data for the task in ebx
 ;         [0x3000] = ebx and [0x3010] = edi
 ;         corrupts other regs
 find_next_task:
         mov   ebx, [CURRENT_TASK]
         mov   edi, [TASK_BASE]
         mov   [prev_slot], ebx
 .waiting_for_termination:
 .waiting_for_reuse:
 .waiting_for_event:
 .suspended:
         cmp   ebx, [TASK_COUNT]
         jb    @f
         mov   edi, CURRENT_TASK
         xor   ebx, ebx
-      @@:
+@@:
         add   edi,0x20
         inc   ebx
         mov   al, byte [edi+TASKDATA.state]
         test  al, al
         jz    .found
 	cmp   al, 1
 	jz    .suspended
 	cmp   al, 2
 	jz    .suspended
         cmp   al, 3
         je    .waiting_for_termination
         cmp   al, 4
         je    .waiting_for_termination
         cmp   al, 9
         je    .waiting_for_reuse
         mov   [CURRENT_TASK],ebx
         mov   [TASK_BASE],edi
         cmp   al, 5
         jne   .noevents
         call  get_event_for_app
         test  eax, eax
         jz    .waiting_for_event
         mov   [event_sched], eax
         mov   [edi+TASKDATA.state], byte 0
 .noevents:
 .found:
         mov   [CURRENT_TASK],ebx
         mov   [TASK_BASE],edi
         rdtsc                     ;call  _rdtsc
         mov   [edi+TASKDATA.counter_add],eax
         mov esi, [prev_slot]
 	xor   eax, eax
         cmp   ebx, esi
         sete  al
 ret
 ; in: ebx = TSS selector index
+;
 ; param
 ;  ebx = incoming task
 ;  esi = outcomig task
 do_change_task:
         shl ebx, 8
         add ebx, SLOT_BASE
         mov [current_slot], ebx
         shl esi, 8
         add esi, SLOT_BASE
         mov [esi+APPDATA.saved_esp], esp
         mov esp, [ebx+APPDATA.saved_esp]
         mov eax, [ebx+APPDATA.dir_table]
         mov cr3, eax
         mov ebx, [ebx+APPDATA.pl0_stack]
         add ebx, RING0_STACK_SIZE
         mov [tss_data+TSS._esp0], ebx
         mov ecx, cr0
         or ecx, CR0_TS   ;set task switch flag
         mov cr0, ecx
         inc   [context_counter] ;noname & halyavin
         ret
+;
 ;        shl   ebx, 3
 ;        xor   eax, eax
 ;        add   ebx, tss0
 ;        mov   [far_jump.sel],  bx   ; selector
 ;        mov   [far_jump.offs], eax  ; offset
 ;        jmp   pword [far_jump]
 ;        inc   [context_counter] ;noname & halyavin
 ;ret
 align 4
 updatecputimes:
         mov  eax,[idleuse]
         mov  [idleusesec],eax
         mov  [idleuse],dword 0
         mov  ecx, [TASK_COUNT]
         mov  edi, TASK_DATA
 .newupdate:
         mov  ebx,[edi+TASKDATA.counter_sum]
         mov  [edi+TASKDATA.cpu_usage],ebx
         mov  [edi+TASKDATA.counter_sum],dword 0
         add  edi,0x20
         dec  ecx
         jnz  .newupdate
         ret
+if 0
+MAX_PROIRITY         0   ; highest, used for kernel tasks
+MAX_USER_PRIORITY    0   ; highest priority for user processes
+USER_PRIORITY        7   ; default (should correspond to nice 0)
+MIN_USER_PRIORITY   14   ; minimum priority for user processes
+IDLE_PRIORITY       15   ; lowest, only IDLE process goes here
+NR_SCHED_QUEUES     16   ; MUST equal IDLE_PRIORYTY + 1
+rdy_head   rd 16
+align 4
+pick_task:
+           xor eax, eax
+.pick:
+           mov ebx, [rdy_head+eax*4]
+           test ebx, ebx
+           jz .next
+           mov [next_task], ebx
+           test [ebx+flags.billable]
+           jz @F
+           mov [bill_task], ebx
+@@:
+           ret
+.next:
+           inc eax
+           jmp .pick
+; param
+;  eax= task
+;
+; retval
+;  eax= task
+;  ebx= queue
+;  ecx= front if 1 or back if 0
+align 4
+shed:
+           cmp [eax+.tics_left], 0 ;signed compare
+           mov ebx, [eax+.priority]
+           setg ecx
+           jg @F
+           mov edx, [eax+.tics_quantum]
+           mov [eax+.ticks_left], edx
+           cmp ebx, (IDLE_PRIORITY-1)
+           je @F
+           inc ebx
+@@:
+           ret
+; param
+;  eax= task
+align 4
+enqueue:
+          call shed  ;eax
+          cmp [rdy_head+ebx*4],0
+          jnz @F
+          mov [rdy_head+ebx*4], eax
+          mov [rdy_tail+ebx*4], eax
+          mov [eax+.next_ready], 0
+          jmp .pick
+@@:
+          test ecx, ecx
+          jz .back
+          mov ecx, [rdy_head+ebx*4]
+          mov [eax+.next_ready], ecx
+          mov [rdy_head+ebx*4], eax
+          jmp .pick
+.back:
+          mov ecx, [rdy_tail+ebx*4]
+          mov [ecx+.next_ready], eax
+          mov [rdy_tail+ebx*4], eax
+          mov [eax+.next_ready], 0
+.pick:
+          call pick_proc     ;select next task
+          ret
+end if

Subversion Repositories Kolibri OS

(root)/kernel/branches/flat_kernel/core/sched.inc – Rev 421 → 427