FryingPan/framework/Generic/Thread.cpp

   1 /*
   2  * Amiga Generic Set - set of libraries and includes to ease sw development for all Amiga platforms
   3  * Copyright (C) 2001-2011 Tomasz Wiszkowski Tomasz.Wiszkowski at gmail.com.
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  18  */
  19
  20 #include "Thread.h"
  21 #include <exec/ports.h>
  22 #include <dos/dos.h>
  23 #include <exec/semaphores.h>
  24 #include <dos/dosextens.h>
  25 #include <dos/dostags.h>
  26 #include <libclass/utility.h>
  27 #include <libclass/exec.h>
  28 #include <libclass/dos.h>
  29 #include <dos/dosextens.h>
  30 #include "HookAttrT.h"
  31 #include "String.h"
  32 #include "Timer.h"
  33 #include "LibrarySpool.h"
  34
  35 #ifndef __MORPHOS__
  36    #define NP_CodeType  TAG_IGNORE
  37    #define CODETYPE_PPC 0
  38 #endif
  39
  40 using namespace GenNS;
  41
  42 void Thread::Create()
  43 {
  44    Message  *m = 0;
  45    MsgPort  *p = 0;
  46
  47    ULONG tags[] = {
  48       NP_Entry,      (ULONG)&__proc_init_code,
  49       NP_StackSize,  65536,
  50       NP_Name,       (unsigned long)hName.Data(),
  51       NP_CodeType,   CODETYPE_PPC,
  52       TAG_DONE,      0
  53    };
  54
  55    pProcess = DOS->CreateNewProc((TagItem*)tags);
  56    p = Exec->CreateMsgPort();
  57    m = new Message;
  58    m->mn_Length         = sizeof(Message);
  59    m->mn_Node.ln_Name   = (char*)this;
  60    m->mn_ReplyPort      = p;
  61    Exec->PutMsg(&pProcess->pr_MsgPort, m);
  62    Exec->WaitPort(p);
  63    m = Exec->GetMsg(p);
  64    Exec->DeleteMsgPort (p);
  65    delete m;
  66 }
  67
  68 void Thread::Terminate()
  69 {
  70    if (!Exec->AttemptSemaphore(pSemaphore))
  71    {
  72       Exec->Signal(&pProcess->pr_Task, lKillSignal);
  73       Exec->ObtainSemaphore(pSemaphore);
  74    }
  75    Exec->ReleaseSemaphore(pSemaphore);
  76 }
  77
  78 bool Thread::IsTerminated()
  79 {
  80    if (Exec->AttemptSemaphore(pSemaphore))
  81    {
  82       Exec->ReleaseSemaphore(pSemaphore);
  83       return true;
  84    }
  85    return false;
  86 }
  87
  88 void Thread::WaitTerminated()
  89 {
  90    Exec->ObtainSemaphore(pSemaphore);
  91    Exec->ReleaseSemaphore(pSemaphore);
  92 }
  93
  94 unsigned long Thread::GetSignals()
  95 {
  96    return lKillSignal | pTimer->GetSignals() | pPort->GetSignals();
  97 }
  98
  99 bool Thread::HandleSignals(int32 ATimeout)
 100 {
 101    return HandleSignals(ATimeout, 0);
 102 }
 103
 104 bool Thread::HandleSignals(int32 ATimeout, uint32 ASignals)
 105 {
 106    unsigned long lSignals = ASignals;
 107    unsigned long lRes;
 108
 109    wasTimer = false;
 110
 111    if ((ATimeout != 0) && (ATimeout != -1))
 112    {
 113       pTimer->AddRequest(ATimeout);
 114    }
 115    else if (ATimeout == 0)
 116    {
 117       pTimer->AbortRequest();
 118    }
 119
 120    lSignals |= GetSignals();
 121    do
 122    {
 123       pPort->HandleSignals();             // if there are any pending messages, handle them at once
 124       if (ATimeout)                       // if timeout has been set...
 125          lRes = Exec->Wait(lSignals);     // wait for any signal or timeout
 126       else                                // otherwise
 127          lRes = Exec->SetSignal(0, lSignals); // just check signals
 128
 129       if (lRes & lKillSignal)             // if we got killed
 130          return true;                     // exit immediately
 131       if (lRes &pTimer->GetSignals())
 132          wasTimer = true;
 133       if (lRes &pPort->GetSignals())      // if we received a new message
 134          pPort->HandleSignals();          // take care of all messages
 135       if (lRes &~pPort->GetSignals())     // otherwise, if it was a timer or any other signal
 136          return false;                    // quit & report
 137    } while (ATimeout);                    // eventually loop.
 138    return false;
 139 }
 140
 141 bool Thread::IsTimerSignal()
 142 {
 143    return wasTimer;
 144 }
 145
 146 void Thread::__proc_init_code()
 147 {
 148    Process          *p;                         // pointer to this process
 149    Message          *m;                         // pointer to received message
 150    Thread           *d;                         // pointer to the class
 151
 152    p = (Process*) Exec->FindTask(0);            // get process message
 153    Exec->WaitPort(&p->pr_MsgPort);              // we expect our class pointer
 154    m = Exec->GetMsg(&p->pr_MsgPort);            // handle it
 155    d = (Thread*)m->mn_Node.ln_Name;             // get class pointer
 156    d->lKillSignal = 1<<Exec->AllocSignal(-1);   // we dont have to free it.
 157    d->pPort       = new Port(0);
 158    d->pTimer      = new Timer();
 159    Exec->ObtainSemaphore(d->pSemaphore);
 160    Exec->ReplyMsg(m);
 161    d->hHook(d, d->pData);
 162    delete d->pPort;
 163    delete d->pTimer;
 164    d->pProcess = 0;
 165    Exec->ReleaseSemaphore(d->pSemaphore);
 166 };
 167
 168 Thread::Thread(const char* AName, const Hook *AHook, void* AData) :
 169    hName(AName),
 170    pData(AData),
 171    hHook(AHook)
 172 {
 173    pSemaphore = new SignalSemaphore;
 174    Exec->InitSemaphore(pSemaphore);
 175    Create();
 176 };
 177
 178 Thread::Thread(const char* AName) :
 179    hName(AName),
 180    pData(0),
 181    hHook(hDefault)
 182 {
 183    hDefault.Initialize(this, &Thread::fDefaultHandler);
 184    pSemaphore  = new SignalSemaphore;
 185    Exec->InitSemaphore(pSemaphore);
 186    Create();
 187 }
 188
 189 Thread::~Thread()
 190 {
 191    Terminate();
 192    delete pSemaphore;
 193 }
 194
 195 void Thread::SetHandler(const Hook *AHandler)
 196 {
 197    pPort->Handler = AHandler;
 198 }
 199
 200 void Thread::DoAsync(unsigned long ACommand, void* ApData)
 201 {
 202    pPort->DoAsync(ACommand, ApData);
 203 }
 204
 205 unsigned long Thread::DoSync(unsigned long ACommand, void* ApData)
 206 {
 207    return pPort->DoSync(ACommand, ApData);
 208 }
 209
 210 void Thread::ProcMessages()
 211 {
 212    pPort->HandleSignals();
 213 }
 214
 215 unsigned long Thread::fDefaultHandler(struct Thread *pThis, void*)
 216 {
 217    pThis->HandleSignals(0xffffffff);
 218    return 0;
 219 }