src/thread/timer.cpp

Idź do dokumentacji tego pliku.

/*
 panaLiX, Adrian Panasiuk 2002-5,8
 http://panalix.sourceforge.net/
 ad.ek336@gmail.com
 
 small osdev project
 provided under GPLv3 license.
 */

#include "src/common/shared.hpp"
#include "src/collection/avltree.hpp"
#include "src/memory/memset.hpp"
#include "src/memory/align.hpp"
#include "src/memory/heap.hpp"
#include "src/thread/timer.hpp"
#include "src/thread/process.hpp"
#include "src/arch/x86/rtc.hpp"
#include "src/ipc/lock.hpp"

namespace Thread {
   namespace Timer {


   struct Memory::Heap::heapbox timer_thread_heapbox;

      struct timer_struct {
         timer_proc proc;
         int arg1, arg2;
         uint32 nextExec;     //the next value of up_time for which the routine is fired; the next moment it is run
         uint32 interval;     //an interval between runs
      };

//   #define lnDb3 do { alert("<< ");alert(__func__);alert(" : "); coutDec(__LINE__);write_bochs_num(__LINE__,10,10000,0);  alert(">> \n");} while(0)
   #define lnDb3 do {} while(0)

   #define MAX_TIMERS_CNT   1000

   //compares first by nextExec but because we may want to have multiple independent timers fire at the same moment
   //we secondly compare by the instance's position in memory
      int timer_struct_cmp(struct timer_struct *a, struct timer_struct *b) {
         if (a->nextExec   >   b->nextExec)
            return 1;
         if (a->nextExec   <   b->nextExec)
            return -1;

         uint32 A= reinterpret_cast<uint32>(a);
         uint32 B= reinterpret_cast<uint32>(b);
         if (A>B)
            return 1;
         if (A<B)
            return 1;

         //returning zero means that a,b point at the same instance
         return 0;
      }

      using namespace Collection;

      class AvlTree<struct timer_struct*, timer_struct_cmp> *tmrs;
      class AvlTree<struct timer_struct*, timer_struct_cmp> *tmrs_pom; //pomocnicza

      volatile uint32 timers_cnt=0;

      class IPC::Lock::lock_t tmrs_lock(const_cast<char*>("timers"));


      void TimerThread () {
         struct Option<struct timer_struct*> item;
         struct timer_struct *ts;
         while(1) {
            uint32 fl;
            ENTER_CRITICAL(fl);
            lnDb3 ;
            tmrs_lock.lock();
            lnDb3 ;
            for (item= tmrs->findMin();
                                       !item.isNone();
                                       item=tmrs->findMin()) {
               ts= item.get();

               if (ts->nextExec > Arch::x86::RTC::up_time)
                  break;
               tmrs->remove(ts);
               timers_cnt--;
               //wybrac procedury do uruchomienia
               tmrs_pom->insert(ts);
               (*(uint32*)0xb8024)++;
            }

            tmrs_lock.ulock();
            LEAVE_CRITICAL(fl);
            lnDb3 ;

            //uruchomic procedury, niektore z nich przygotowac do nastepnego uruchomienia
            for (item= tmrs_pom->findMin();
                                          !item.isNone();
                                          item= tmrs_pom->findMin()) {
               ts= item.get();
               tmrs_pom->remove(ts);
               //odpalic rutyne
               if (ts->proc(ts->arg1,ts->arg2) == 1) { // ==1 oznacza, ze wstawic ponownie do listy timerow
                  ts->nextExec += ts->interval; // no overhead-generated time slips, it runs every [interval] ticks, perhaps a few ticks late, but it doesn't cumulate

                  ENTER_CRITICAL(fl);
                  lnDb3 ;
                  tmrs_lock.lock();
                  lnDb3 ;
                  tmrs->insert(ts); //ponownie wstawic
                  tmrs_lock.ulock();
                  LEAVE_CRITICAL(fl);
                  lnDb3 ;
               } else {
                  //nie wstawiac ponownie
                  timer_thread_heapbox.free(ts);
               }

            }

//            tmrs_lock.lock();
//         // ponownie wstawic wyroznione rutyny do tmrs
//            for (item= tmrs_pom->findMin();
//                                           !item.isNone();
//                                           item= tmrs_pom->findMin()) {
//
//                  ts= item.get();
//                  tmrs_pom->remove(ts);
//                  tmrs->insert(ts);
//               }
//
//            tmrs_lock.ulock();
            Thread::sleep(1);
         }
      }

      struct timer_handle add(timer_proc proc, uint32 interval, int arg1, int arg2) {
         struct timer_struct *ts;
            ts= static_cast<struct timer_struct*>(timer_thread_heapbox.malloc(sizeof(struct timer_struct),1,"timer struct",null));
            ts->proc=proc;
            ts->arg1=arg1;
            ts->arg2=arg2;
            ts->interval=interval;
            ts->nextExec= Arch::x86::RTC::up_time+ interval;
            uint32 fl; ENTER_CRITICAL(fl);
            lnDb3 ;
            tmrs_lock.lock();
            lnDb3 ;
            if (timers_cnt > MAX_TIMERS_CNT) {
//               complain("too many timers"); 
               sysfail("too many timers");
               tmrs_lock.ulock();
               LEAVE_CRITICAL(fl);
               timer_thread_heapbox.free(ts);
               //Thread::sleep(100);
               return timer_handle();
            }
            tmrs->insert(ts);
            timers_cnt ++;
            tmrs_lock.ulock();
            LEAVE_CRITICAL(fl);
            lnDb3 ;
            return timer_handle(reinterpret_cast<uint32>(ts));
      }

      bool remove(struct timer_handle &hndl) {
         uint32 fl;
         ENTER_CRITICAL(fl);
         lnDb3 ;
         tmrs_lock.lock();
         lnDb3 ;
         bool x= tmrs->remove(reinterpret_cast<struct timer_struct*>(hndl.d));
         timers_cnt --;
         tmrs_lock.ulock();
         LEAVE_CRITICAL(fl);
         timer_thread_heapbox.free(reinterpret_cast<struct timer_struct*>(hndl.d));
         lnDb3 ;
         hndl=0;
         return x;
      }

      void initTimerThread() {
         Memory::Heap::allocate_heapbox(&timer_thread_heapbox, "timer thread");
         //tmrs = static_cast<class Collection::AvlTree<struct timer_struct*, timer_struct_cmp> *>
//                  (kmalloc(sizeof(class Collection::AvlTree<struct timer_struct*, timer_struct_cmp>), "timers coll"));
//         tmrs->AvlTree();
         tmrs = new class Collection::AvlTree<struct timer_struct*, timer_struct_cmp>;
         tmrs_pom = new class Collection::AvlTree<struct timer_struct*, timer_struct_cmp>;
         Thread::kernel_process.create_thread(true, (uint32)&TimerThread, 2, 2, const_cast<char*>("timers"));
      }


  }
}

---