src/thread/thread.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                             *
************************************************************
*       thread.cpp, version 1.0                            *
************************************************************
*                                                          *
*basic thread datatypes, operations                        *
*                                                          *
*12'05'04- first revision (1.0)                            *
*                                                          *
***********************************************************/

#include "src/common/shared.hpp"
#include "src/common/blist.hpp"
#include "src/common/blistsort.hpp"
#include "src/arch/x86/interr.hpp"
#include "src/arch/x86/except_c.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/thread/scheduler.hpp"
#include "src/thread/thread.hpp"
#include "src/thread/process.hpp"

namespace Thread {

//vars
class IPC::Lock::lock_t lock_queues("queues");
class IPC::Lock::lock_t lock_sleep("sleep");
class Memory::Heap::heapbox heap;       //the heap for the queues
class blist_t threads_queue[THREAD_QUEUES];
// class blist_t threads_ran;   //threads which have been ran
class blist_t threads_sleep;    //sleeping threads
class blist_t threads_dead;     //the cementary

//wake the sleeping threads
int wake_threads()
 { _PF;
blist_s *item, *next;
thread_t *thread;
//multitasking
        if (!Thread::Scheduler::multitasking_running)
                Preturn(EFAIL);
//locks
        if (lock_system.locked())
                Preturn(EFAIL);
        if (lock_queues.locked())
                Preturn(EFAIL);
        if (lock_sleep.locked())
                Preturn(EFAIL);
//awake all the necessary threads
        for (item=threads_sleep.head;item;item=next)
         {
                next=item->next;
                thread=bli_dt(item,thread_t*);
        //check awake time, in the sorted list
                if (thread->awake_time > Arch::x86::RTC::up_time)
                        break;
                awake(thread);
         }

        Preturn(ESUCCESS);
 }

//add a thread to the queue
int enqueue_thread(thread_t *thread, blist_t *queue)
 {
int i;
        lock_queues.lock();
        i= (queue->ptr(thread, NULL)==NULL? EFAIL : ESUCCESS);
        lock_queues.ulock();
        return i;
 }

//delete a thread from a queue
int unqueue_thread(thread_t *thread, blist_t *queue)
 { _Pf("T'::unqueue_thread");
blist_s *item;
        lock_queues.lock();
        for (item=queue->head;item;item=item->next)
         {
                if (bli_dt(item,thread_t*) != thread)
                        continue;
                queue->del(item);
                lock_queues.ulock();
                preturn( ESUCCESS );
         }

        lock_queues.ulock();
        preturn( EFAIL );
 }

//counts the load, in 1/100%
uint32 thread_load(thread_t *thread) { _Pf("Thread::thread_load");
uint32 i;
        if (Arch::x86::RTC::up_time - thread->save1_time > 29)  //prior_thread()(scheduler.cpp) uses 30, so here- 29
         {
                thread->save1_time=thread->save2_time;
                thread->run1_time=thread->run2_time;
                thread->save2_time=Arch::x86::RTC::up_time;
                thread->run2_time=thread->running_time;
         }
//      i=thread->load*10/100;
        i= 2000 * (thread->running_time) /
                ( Arch::x86::RTC::up_time-thread->creation_time);
        if (thread->run1_time != 0) {
//      i= 10000 * (thread->running_time-thread->run1_time) /
//              ( Arch::x86::RTC::up_time-/*thread->creation_time*/thread->save1_time);
//      else
        if (thread->save1_time >= Arch::x86::RTC::up_time)
           i+= 8000 * (thread->running_time) /
                ( Arch::x86::RTC::up_time-thread->creation_time);
           else
        i+= 8000 * (thread->running_time-thread->run1_time) /
                ( Arch::x86::RTC::up_time-/*thread->creation_time*/thread->save1_time);
   }

//      i+= 4000 * (thread->running_time-thread->run2_time) /
//              ( Arch::x86::RTC::up_time-/*thread->creation_time*/thread->save2_time);
//      if ( Arch::x86::RTC::up_time - thread->creation_time > 100) {
//              thread->running_time=1;
//              thread->creation_time=Arch::x86::RTC::up_time; }
        thread->load=i;
        preturn( thread->load );
//      returns thread->load;
 }

//compare two threads for sleeping time
int sleepcompar(const void *a, const void *b)
 { _Pf("T'::sleepcompar");
uint64 A, B;
        A= bli_dt(a,thread_t*)->awake_time;
        B= bli_dt(b,thread_t*)->awake_time;

        if (A > B)
                preturn( 1);
        if (B > A)
                preturn( -1);
        preturn( 0);
 }

//sleep a thread
int sleep(thread_t *thread, uint64 time)
 { _Pf("Thread::sleep");
int i;
//lock
// cout("(A)");
uint32 fl;
        asm volatile("pushf\npopl %0\ncli":"=g"(fl));
        Scheduler::lock_scheduler.lock();
        lock_sleep.lock();
        lock_system.lock();
        if (time != 0)
                thread->awake_time=Arch::x86::RTC::up_time+time;
        else
                thread->awake_time=0xffffffffffffffffll;
// cout("(B)");
//remove from the running threads
        i=unqueue_thread(thread, &threads_queue[thread->priority]);
        if (i!= ESUCCESS)
                if (current_thread==thread) i=ESUCCESS;
//              i=unqueue_thread(thread, &threads_ran);
        if (i!= ESUCCESS) {
                lock_system.ulock();
                lock_sleep.ulock();
                Scheduler::lock_scheduler.ulock();
                asm volatile("pushl %0\npopf"::"g"(fl));
                preturn( i ); }
// cout("(C)");
//add to the sleeping threads, unless it's a zombie
        if ((thread->state & TH_DYING) == 0) {
                lock_queues.lock();
                i= (blistsort_ptr(&threads_sleep, thread, NULL, &sleepcompar)==NULL? EFAIL:ESUCCESS);
                lock_queues.ulock(); }
// cout("(D)");

//change state
        thread->state&=(0xFFFFFFFF- TH_ACTIVE-TH_BUSY);
        thread->state|=TH_ASLEEP;
//      thread->running_time+=Arch::x86::RTC::up_time - thread->work_time;
// cout("(E)");

//ulock
        lock_system.ulock();
        lock_sleep.ulock();
        Scheduler::lock_scheduler.ulock();
        asm volatile("pushl %0\npopf"::"g"(fl));
// cout("(F)");
//block, if sleeping current_thread
        if (thread==current_thread) {
           asm volatile ("int $0x20":::"memory");       //to make the scheduler react as fast as possible
                do {} while (thread->state & TH_ASLEEP);
   }
// cout("(G)");
        preturn(  i  );
 }

//sleep current_thread
int sleep(uint64 time) {
        return sleep((Thread::thread_t*)current_thread, time);
 }

//awake a thread
int awake(thread_t *thread)
 { _Pf("Thread::awake");
int i;
uint32 fl;
        asm volatile("pushf\npopl %0\ncli":"=g"(fl));
        if (Thread::Scheduler::multitasking_running==false)
                { asm volatile ("pushl %0\npopf"::"g"(fl)); preturn( EINVAL ); }
//check if a thread is asleep
        if ((thread->state&TH_ASLEEP)==0)
                { asm volatile ("pushl %0\npopf"::"g"(fl)); preturn( EINVAL ); }
//lock
        Scheduler::lock_scheduler.lock();
        lock_sleep.lock();
        lock_system.lock();
//remove from asleep threads
        i=unqueue_thread(thread, &threads_sleep);
        if (i!= ESUCCESS) {
                lock_system.ulock();
                Scheduler::lock_scheduler.ulock();
                lock_sleep.ulock();
                asm volatile ("pushl %0\npopf"::"g"(fl));
                preturn( i ); }
//change state
        thread->state&=(0xffffffff-TH_ASLEEP);
        thread->state|=TH_ACTIVE;
//add to waiting threads
//      enqueue_thread(thread, &threads_ran);
        enqueue_thread(thread, &threads_queue[thread->priority]);
//ulock
        lock_system.ulock();
        lock_sleep.ulock();
        Scheduler::lock_scheduler.ulock();

        asm volatile ("pushl %0\npopf"::"g"(fl));
        preturn( ESUCCESS );
 }

//put a thread to sleep on a sem
int sem_sleep(thread_t *thread, struct sem_t *sem_id, uint64 sem_dt)
 {
        thread->sem_id=sem_id;
        thread->sem_dt=sem_dt;
        return sleep(thread,0);
 }

//put current_thread to sleep on a sem
int sem_sleep(struct sem_t *sem_id, uint64 sem_dt) {
        return sem_sleep((Thread::thread_t*)current_thread, sem_id, sem_dt);
 }

//awake a thread from sem
int sem_awake(thread_t *thread)
 {
        thread->sem_id=NULL;
        thread->sem_dt=0;
        return awake(thread);
 }

thread_t *ThreadGet(int procno, int threadno)
 {
process_t *proc;
        proc= ProcessGet(procno);
        if (proc==NULL) return NULL;

blist_s *item;
        for(item=proc->thread_list.head;item&&(bli_dt(item,thread_t*)->no<=threadno);item=item->next)
                if (bli_dt(item,thread_t*)->no==threadno)
                        return bli_dt(item,thread_t*);

        return NULL;
 }

int ThreadKill(thread_t *thread)
 {
uint32 fl;
        asm volatile("pushf\npopl %0\ncli":"=g"(fl));
//change state significantly. From a wealthy, nice thread to a dying zombie
        thread->state|=TH_DYING;
        threads_dead.ptr(thread, NULL);
        asm volatile("pushl %0\npopf"::"g"(fl));

        return sleep(thread, 0);
 }

int ThreadKill(int procno, int threadno) {
        return ThreadKill(ThreadGet(procno, threadno));
 }

 };     /*namespace Thread*/
/***********************************************************
*                                                          *
*panalix 0.06 (c) Adrian Panasiuk 2002-4                   *
*adek336[at]o2.pl, panalix.prv.pl                          *
*                                                          *
***********************************************************/

---