src/thread/scheduler.cpp

Idź do dokumentacji tego pliku.

/***********************************************************
*PANALIX 0.06, (c) Adrian Panasiuk 2002-4                  *
*adek336[at]o2.pl, panalix.prv.pl                          *
*under GPLv3 license                                       *
*                                                          *
*panalix - small osdev project                             *
************************************************************
*       scheduler.cpp, version 1.0                         *
************************************************************
*                                                          *
*this piece of code manages the processes/threads, and     *
*selects which of them is supposed to be ran next.         *
*                                                          *
*02'05'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/blist.hpp"
#include "src/common/blistsort.hpp"
#include "src/common/string.hpp"
#include "src/mboot.hpp"
#include "src/module/elf.hpp"
#include "src/module/mangle.hpp"
#include "src/module/coresyms.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/mmap.hpp"
#include "src/memory/alloc4k.hpp"
#include "src/memory/shmem.hpp"
#include "src/ipc/msg.hpp"
#include "src/ipc/sem.hpp"
#include "src/arch/x86/gdt.hpp"
#include "src/arch/x86/context.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/arch/x86/irq.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/thread/process.hpp"
#include "src/thread/scheduler.hpp"

volatile struct Thread::thread_t *current_thread;

namespace Thread {


struct thread_t *MemsetThreadHandle=NULL,*IdleThreadHandle=NULL;

//count a priority for a thread. if move==true, will move to the new queue from the old queue #i
void count_prior(thread_t *thread, uint32 i, bool move)
 {
uint32 new_prior;
//count a priority
        new_prior=MIN(thread->worst_priority,
                ( (THREAD_QUEUES) * thread_load(thread) / 10000 ));
        new_prior=MAX(thread->best_priority, new_prior);
//change priorities slowly
        if (thread->priority > new_prior)
                thread->prior_diff--;
        if (thread->priority < new_prior)
                thread->prior_diff++;
//but when the thread seems to need a priority change..
        if (ABS(thread->prior_diff)>=PRIOR_THREAD_DELTA)
         {
        //increase or decrease by one
                if (thread->prior_diff < 0)
                        new_prior=MAX(thread->priority-1, 2);
                if (thread->prior_diff > 0)
                        new_prior=MIN(THREAD_QUEUES-1, thread->priority+1);
        //clear the counter and setup new priority
                thread->prior_diff=0;
                thread->priority=new_prior;
        //if necessary, move the thread to another queue
                if (move)
                 {
                        lock_system.lock();
                        lock_queues.ulock();
                        unqueue_thread(thread, &threads_queue[i]);
                        enqueue_thread(thread, &threads_queue[new_prior]);
                        lock_queues.lock();
                        lock_system.ulock();
                 }      /*fi*/
         }      /*fi*/
 }      /*end count_prior*/

//the scheduling thread
void prior_thread()
 {
uint32 i,n;
/* first task- free memory from the kernel's first stack */
        for (i=0; i<CRT_STACK_SIZE; i+= PAGE_SIZE)
         {
                n= Memory::Pager::kmem.pte_val(0xfffff000&(i+(uint32)&CRT_STACK));
                if (n & PTE_PRESENT)    //free only present pages
                        disalloc4k ( n&0xfffff000 );
         }

blist_s *item,*next;
//strawberry fields- 4ever
        while (true)
         {
                Thread::sleep(PRIOR_THREAD_SLEEP);
                lock_queues.lock();
        //count priorities for all active threads
                for (i=0;i<THREAD_QUEUES;i++)
                for (item=threads_queue[i].head;item;item=next)
                 {      next=item->next;
                        count_prior(bli_dt(item,thread_t*), i, true);
                 }
        //count priorities for all sleeping threads
                for (item=threads_sleep.head;item;item=next)
                 {      next=item->next;
                        count_prior(bli_dt(item,thread_t*), 0, false);
                 }
                lock_queues.ulock();
         }
 }

// cleanup and forget about him
int ThreadFinishOff(thread_t *thread)
 {
/* A thread is given the following resources: a stack(process_t::mmap_t); an entry in the process_t::thread_list; (possibly)
an interrupt stack (check out chain_handler and friends); a mailbox; an environment (not much yet- thread_t::env) */
blist_s *item,*next;
process_t *proc= thread->proc;
mmap_s *node;
        thread->state|=TH_BLOCKED;
// free the interrupt stack
        if (thread->env.cd!= NULL)
         {
                Arch::x86::Interr::stackVac--;
                Arch::x86::Interr::stackPtr[Arch::x86::Interr::stackVac]=thread->env.cd->stack;
         }

// destroy mailbox
        thread->inbox.done();
// environment
        thread->env.cd= NULL;
// destroy all mmap_t objects related with the thread
        for (item=proc->mem->memory_map.map.head;item;item=next)
         {
                next= item->next;
                node= bli_dt(item,struct mmap_s*);
                if (node->thread==thread->no)
                 {
                        if (node->destroy)
                                node->destroy(&proc->mem->memory_map,node);
                        proc->mem->memory_map.mdel(item);
                 }
         }
// forget about the thread by deleting it from lists
        threads_dead.del(threads_dead.find(thread));
        proc->thread_list.del(proc->thread_list.find(thread));  //this operation frees the memory from the thread_t struct

        return ESUCCESS;
 }

// die! die! die my darling!
int ProcFinishOff(process_t *proc)
 {
/* A process is given the following resources: threads (which have to be all dead when calling this method);
a memory space; objects within the memory space (process_t::mmap_t); a heapbox; an environment (not much yet- process_t::env)*/
//sanity- are there any threads left?
        lock_queues.lock();
bool b= (proc->thread_list.head!=NULL);
        lock_queues.ulock();
        if (b)
                return EINVAL;
//the environment
        proc->env.api=0;        //lol this is useless
//the heapbox
        proc->heap.destruct();
//objects in the memtree
        proc->mem->memory_map.done();
//the memory space; ouch. after this, the process is HISTORY
        proc->mem->done();
//delete from lists. BUAHAHA this means "forget forever"
        Processes.del(Processes.find(proc));

        return ESUCCESS;
 }

// find all the damn zombies, and shazam!, get them dead.
void ZombieSlayerThread()
 {
blist_s *item,*next;
thread_t *thread;
process_t *proc;

        while(true) {
                (*(uint64*)(0xb8030))++;
        //do not waste processor power at all times
#if DISABLE_FAST_MOVING_CHARS
                Thread::sleep(1);
#endif
// IPC::Message::message *msg;
// current_thread->inbox.kreceive(&msg);
// cout((char*)(msg+1));
// current_thread->inbox.free_msg(msg);
                item=threads_dead.head; //won't gcc cache the threads_dead.head value?
        //find a zombie thread
                for ( ; item; item=next)
                 {
                        next= item->next;
                // get info
                        thread= bli_dt(item,thread_t*);
                        proc= thread->proc;
                // finish the thread
                        ThreadFinishOff(thread);
                        if (proc->thread_list.head==NULL)
                                ProcFinishOff(proc);
                 }/*for*/
        }/*while*/
 }/*ZombieSlayerThread*/

// memset all free pages, so that any alloc4k() returns a page empty of data
void MemsetThread()
 {
uint32 addr;
int i;
        while(true) {
// blist_s *item;
// Memory::Heap::heapbox *hp;
//      for (item=Memory::Heap::HeapList.head;item;item=item->next)
//       {
//              hp= bli_dt(item,Memory::Heap::heapbox*);
//              cout(hp->name);
//              kprintf("\n--allocs=%x, used=%x\n", hp->stats.allocs, hp->stats.used);
//       }

                sleep(1);
      //sleep (400);run the thread rarely
// thread_t *t;
//      t=ThreadGet(1,2);
// current_thread->inbox.ksend(&t->inbox,(char*)"abc",4,0);
// sleep(1);
        //clear some pages, doh
                while (Memory::Physical::zero_pages_high.length() < Memory::Physical::PAGESCLEANMAX)
                 {
                        addr= Memory::Physical::alloc4kDirty_high(1);
                        if (addr==NULL)
                                break;
                        i= Memory::Physical::zero_pages_high.free(addr);
                        if (i!=ESUCCESS) say(const_cast<char*>("high- %x"), addr);
                 }
                while (Memory::Physical::zero_pages_low.length() < Memory::Physical::PAGESCLEANMAX)
                 {
                        addr= Memory::Physical::alloc4kDirty_low(1);
                        if (addr==NULL)
                                break;
                        i= Memory::Physical::zero_pages_low.free(addr);
                        if (i!=ESUCCESS) say(const_cast<char*>("low- %x"), addr);
                 }
        }/*while*/
 }/*MemsetThread*/

/* idle thread */
void IdleThread()
 {
        while (true)
         {
                asm volatile("sti\nhlt");
         }
 }

thread_t volatile *t1=NULL,*t2=NULL;
//class Sandbox::IPC::Message::mailbox k1,k2,k3;
int volatile i=0;
void ABCThread()
 {
   while(1) Thread::sleep(1);
//struct Sandbox::IPC::Message::message msg, *m;
        switch (current_thread->proc->no)
         {
                case 1:
                        i=1;
//                      Sandbox::IPC::Message::allocate_mailbox(&k1, current_thread, &current_thread->proc->heap);
                        i=2;
//                      while (i!=4);
                        //k1.kreceive(&m, /*&k3*/NULL);cout(m->MsgBuf);k1.free_message(m);
                        //k1.kreceive(&m, /*&k3*/NULL);cout(m->MsgBuf);k1.free_message(m);
                        //k1.kreceive(&m, /*&k3*/NULL);cout(m->MsgBuf);k1.free_message(m);
                        //k1.kreceive(&m, /*&k3*/NULL);cout(m->MsgBuf);k1.free_message(m);
                        //k1.kreceive(&m, /*&k3*/NULL);cout(m->MsgBuf);k1.free_message(m);
                        //k1.kreceive(&m, /*&k3*/NULL);cout(m->MsgBuf);k1.free_message(m);
                        
                        break;
                case 2:
                        while (i!=2) ;
                        //Sandbox::IPC::Message::allocate_mailbox(&k2, current_thread, &current_thread->proc->heap);
//                      k2.allocate_message(&msg, &k1, 0);
//                      memmove((void*)&msg.MsgBuf, (void*)"hello world", 12);
//                      k2.ksend(&msg);
//                      memmove((void*)&msg.MsgBuf, (void*)"hi! how are you?", 17);
//                      k2.ksend(&msg);
                        //k2.ksend(&msg);
                        i=3;
                        break;
                case 3:
                        while (i!=3) ;
                        //Sandbox::IPC::Message::allocate_mailbox(&k3, current_thread, &current_thread->proc->heap);
//                      k3.allocate_message(&msg, &k1, 0);
                        //memmove((void*)&msg.MsgBuf, (void*)"seek and destroy", 17);
                        //k3.ksend(&msg);
                        i=4;
                        break;
         }
        for(;;);
// int i;
//      switch (current_thread->proc->no)
//       {
//              case 1:
//                      cout("1: alloc..");
// //                   current_thread->proc->mem->pte_map(0x10000000, alloc4k(1,true)|3);
// //                   current_thread->proc->mem->pte_map(0x10001000, alloc4k(1,true)|3);
// //                   current_thread->proc->mem->pte_map(0x10002000, alloc4k(1,true)|3);
//                      current_thread->proc->mem->pte_map(0x10000000, PTE_LAZY);
//                      current_thread->proc->mem->pte_map(0x10001000, PTE_LAZY);
//                      current_thread->proc->mem->pte_map(0x10002000, PTE_LAZY);
//                      cout(" 1:ok\n");
//                      memmove((void*)0x10001000, (void*)"HELLO WORLD", 12);
//                      cout("1: create..");
//                      i= Memory::Shmem::shmem_create((Memory::Shmem::shmem_t*)&shmem, current_thread->proc->mem, 0x10000000, 0x3000, true, true);
//                      cout(" 1:ok\n");
//                      x=2;
//                      break;
//              case 2:
//                      while (x!=2) ;
//                      cout("2: attach.. ");
//                      i= Memory::Shmem::shmem_attach((Memory::Shmem::shmem_t*)&shmem, current_thread->proc->mem, 0x20000000, 0x1000, 0x1000, true);
//                      cout("2ok\n2: >");
//                      cout((char*)0x20000000);
//                      cout("<\n");
//                      memmove((void*)0x20000000, (void*)"hello world", 12);
//                      cout("2e\n");
//                      cout("2: >");
//                      cout((char*)0x20000000);
//                      cout("<\n");
//                      x=3;
//                      break;
//              case 3:
//                      while (x!=3) ;
//                      write_bochs("f");
//                      cout("3: attach.. ");
//                      i= Memory::Shmem::shmem_attach((Memory::Shmem::shmem_t*)&shmem, current_thread->proc->mem, 0x30000000, 0x1000, 0x1000, false);
//                      cout("3ok\n3: >");
//                      cout((char*)0x30000000);
//                      cout("<\n");
//                      cout("3e\n");
//                      Debug::Profiler::stats(true);Debug::Profiler::stats(true);
//                      x=4;
//                      break;
//       };
// 
//      for (;;);
 }

void MatkaTeresaThread()
 {
   while(1) Thread::sleep(1);
t2=current_thread;
while (t1==NULL); 
// char *ch="world! ";
// IPC::Message::message *msg;
        while(1)
         {
//              (*(IPC::Message::mailbox*)&t2->inbox).ksend((IPC::Message::mailbox*)&t1->inbox, ch, 8, 0);
//              (*(IPC::Message::mailbox*)&t2->inbox).kreceive(&msg, (IPC::Message::mailbox*)&t1->inbox);
                sleep(1);
//              cout((char*)(msg+1));
//              (*(IPC::Message::mailbox*)&t2->inbox).free_msg(msg);
         }
 }

void BaonKilinski()
 {
   while(1) Thread::sleep(1);
//      sleep(0);
        while (t1==NULL);
        while (t2==NULL);
        while (1)
         {
(*(char*)(0xb8004))++;
                if (t1->state&TH_ASLEEP)
                        (*(char*)(0xb8000))='-'; else
                        (*(char*)(0xb8000))='x';
//                      cout(" "); else
//                      cout("x");
                if (t2->state&TH_ASLEEP)
//                      cout(" "); else
//                      cout("x");
                        (*(char*)(0xb8002))='-'; else
                        (*(char*)(0xb8002))='x';
//              sleep(100);
//              cout("\t");
//              sleep(200);
         }
 }
class process_t proc2, proc3;
class Memory::Pager::memtree m2,m3;
/*prepare multitasking*/
void init()
{
   uint32 i;
   // init the Processes list
   Processes.init("proclist", &Memory::Heap::heap0);
   // init thread lists
   for (i=0;i<Thread::THREAD_QUEUES;i++)
      Thread::threads_queue[i].init(FAC_THREAD|FAC_THRLIST, &Thread::heap);
   Thread::threads_sleep.init(FAC_THREAD|FAC_THRSLEEP, &Thread::heap);
   Thread::threads_dead.init("threads dead blist", &Thread::heap);
   Thread::lock_queues.ulock();
   Thread::Scheduler::lock_scheduler.ulock();
   // allocate a heapbox for the scheduler thread lists
   if (allocate_heapbox(&Thread::heap, const_cast<char*>("scheduler")) != ESUCCESS)
      sysfail("heapbox not allocated");
   // init kernel process
   allocate_memtree(&m2,true,&Memory::Heap::heap0);     //create a memory space, yea
   allocate_memtree(&m3,true,&Memory::Heap::heap0);     //create a memory space, yea
   kernel_process.init(const_cast<char*>("proc_kern0"), &Memory::Pager::kmem);
   Thread::ProcessRegister(&kernel_process);
   proc2.init(const_cast<char*>("proc2"), &m2);
   Thread::ProcessRegister(&proc2);
   proc3.init(const_cast<char*>("proc3"), &m3);
   Thread::ProcessRegister(&proc3);


   // create system threads
   kernel_process.create_thread(true, (uint32)&prior_thread, 0, 0, const_cast<char*>("thread_prior"));
   kernel_process.create_thread(true, (uint32)&ABCThread,20,0,const_cast<char*>("YO1"));
   //   kernel_process.create_thread(true, (uint32)&ABCThread,0,0,"YO");
   proc2.create_thread(true, (uint32)&ABCThread,20,0,const_cast<char*>("YO2"));
   proc3.create_thread(true, (uint32)&ABCThread,20,0,const_cast<char*>("YO3"));
   //   kernel_process.create_thread(true, (uint32)&MatkaTeresaThread,0,0,"AMEN");
   //   kernel_process.create_thread(true, (uint32)&BaonKilinski,0,0,"Baon AK Kilinski");
   kernel_process.create_thread(true, (uint32)&ZombieSlayerThread, 15, 3, const_cast<char*>("zombie slayer"));
   IdleThreadHandle=kernel_process.create_thread(true, (uint32)&IdleThread, THREAD_QUEUES-1, THREAD_QUEUES-1, const_cast<char*>("idle"));
   MemsetThreadHandle= kernel_process.create_thread(true, (uint32)&MemsetThread, 15, 3, const_cast<char*>("memset"));

   // select a thread
   // Note: the thread selected here gets an additional time slice.
   IdleThreadHandle->state|=TH_IDLE;
   current_thread=MemsetThreadHandle;
   current_thread->work_time=Arch::x86::RTC::up_time;
}


namespace Scheduler {


bool volatile multitasking_running=false;       //whether we made the first switch
class IPC::Lock::lock_t lock_scheduler("scheduler");

//choose an important thread
int choose_high()
 {
uint32 i;
thread_t *dt;
        for (i=0;i<THREAD_QUEUES;i++)
         {
                if (threads_queue[i].head == NULL)
                        continue;
                dt=bli_dt(threads_queue[i].head,thread_t*);
//              unqueue_thread(dt, &threads_queue[i]);
//              enqueue_thread(dt, &threads_ran);
                unqueue_thread(dt, &threads_queue[i]);
//              enqueue_thread(dt, &threads_queue[dt->priority]);
                current_thread=dt;
//              cout ((char*)&dt->name);
                return ESUCCESS;
         }

        return EFAIL;
 }

volatile uint32 time_slices=0;

//choose a new thread to be ran
int choose_next_thread()
 {
        multitasking_running=true;
/* check locks */
        if (lock_system.locked())
                return EFAIL;
        if (lock_scheduler.locked())
                return EFAIL;
        if (lock_queues.locked())
                return EFAIL;
 
   time_slices ++ ;
//change state
        current_thread->state &= (0xFFFFFFFF-TH_BUSY);
        current_thread->running_time+=Arch::x86::RTC::up_time - current_thread->work_time;
        if (current_thread->state & TH_ACTIVE)
        if ((current_thread->state & TH_IDLE)==0)
                enqueue_thread((Thread::thread_t*)current_thread, &threads_queue[current_thread->priority]);

/* select an important thread */
        if (choose_high() != ESUCCESS)
                {       //when no other threads are availlable, checkout the idle one
                unqueue_thread(IdleThreadHandle,&threads_queue[IdleThreadHandle->priority]);
                current_thread=IdleThreadHandle; }

        asm volatile("mov %%eax, %%cr3"::"a"( current_thread->proc->mem->cr3 ));
//change state
        current_thread->state|=TH_BUSY;
        current_thread->work_time=Arch::x86::RTC::up_time;

        return ESUCCESS;
 }



  };    /*namespace Scheduler*/


 };     /*namespace Thread*/

/*Gdy b?dziesz w pustym pokoju ,
  a po policzku pop?ynie ?za ,
  to nie my?l , ?e? sam na ?wiecie - 
  bo razem z Tob? jestem ja.

- od Joelki.. :* */
 
 
/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/






/* historia
skróty AK SZP NSZ
konferencja w Teheranie
tekst ?ród?owy o Katyniu
zdania chronologicznie
pozorowanie wojny przez Niemcy
bilans II W? 
holokaust
kolaboracja
krzy?ówka z has?em
traktowanie Polaków przez okupantów*/

---