#include <threads.h>
#include <errno.h>
+// Configuration
#define DEBUG_TRACE_TICKETS 0 // Trace ticket counts
#define DEBUG_TRACE_STATE 0 // Trace state changes (sleep/wake)
+// --- Schedulers ---
+#define SCHED_UNDEF 0
+#define SCHED_LOTTERY 1 // Lottery scheduler
+#define SCHED_RR_SIM 2 // Single Queue Round Robin
+#define SCHED_RR_PRI 3 // Multi Queue Round Robin
+// Set scheduler type
+#define SCHEDULER_TYPE SCHED_LOTTERY
+
// === CONSTANTS ===
#define DEFAULT_QUANTUM 10
-#define DEFAULT_TICKETS 5
-#define MAX_TICKETS 10
+#define DEFAULT_PRIORITY 5
+#define MIN_PRIORITY 10
const enum eConfigTypes cCONFIG_TYPES[] = {
CFGT_HEAPSTR, // e.g. CFG_VFS_CWD
CFGT_INT, // e.g. CFG_VFS_MAXFILES
extern tThread *Proc_GetCurThread(void);
extern int Proc_Clone(Uint *Err, Uint Flags);
extern void Proc_CallFaultHandler(tThread *Thread);
+extern int GetCPUNum(void);
// === PROTOTYPES ===
void Threads_Init(void);
- int Threads_SetName(char *NewName);
+ int Threads_SetName(const char *NewName);
char *Threads_GetName(int ID);
-void Threads_SetTickets(tThread *Thread, int Num);
+void Threads_SetPriority(tThread *Thread, int Pri);
tThread *Threads_CloneTCB(Uint *Err, Uint Flags);
int Threads_WaitTID(int TID, int *status);
tThread *Threads_GetThread(Uint TID);
void Threads_AddToDelete(tThread *Thread);
-tThread *Threads_int_GetPrev(tThread **List, tThread *Thread);
+tThread *Threads_int_DelFromQueue(tThread **List, tThread *Thread);
void Threads_Exit(int TID, int Status);
void Threads_Kill(tThread *Thread, int Status);
void Threads_Yield(void);
tGID Threads_GetGID(void);
int Threads_SetGID(Uint *Errno, tUID ID);
void Threads_Dump(void);
+void Threads_DumpActive(void);
+
void Mutex_Acquire(tMutex *Mutex);
void Mutex_Release(tMutex *Mutex);
int Mutex_IsLocked(tMutex *Mutex);
ThreadName: "ThreadZero", // Name
Quantum: DEFAULT_QUANTUM, // Default Quantum
Remaining: DEFAULT_QUANTUM, // Current Quantum
- NumTickets: DEFAULT_TICKETS // Number of tickets
+ Priority: DEFAULT_PRIORITY // Number of tickets
};
// -- Processes --
// --- Locks ---
tShortSpinlock glThreadListLock; ///\note NEVER use a heap function while locked
// --- Current State ---
volatile int giNumActiveThreads = 0; // Number of threads on the active queue
-volatile int giFreeTickets = 0; // Number of tickets held by non-scheduled threads
volatile Uint giNextTID = 1; // Next TID to allocate
// --- Thread Lists ---
tThread *gAllThreads = NULL; // All allocated threads
-tThread *gActiveThreads = NULL; // Currently Running Threads
tThread *gSleepingThreads = NULL; // Sleeping Threads
tThread *gDeleteThreads = NULL; // Threads to delete
int giNumCPUs = 1; // Number of CPUs
BOOL gaThreads_NoTaskSwitch[MAX_CPUS]; // Disables task switches for each core (Pseudo-IF)
+// --- Scheduler Types ---
+#if SCHEDULER_TYPE == SCHED_LOTTERY
+const int caiTICKET_COUNTS[MIN_PRIORITY+1] = {100,81,64,49,36,25,16,9,4,1,0};
+volatile int giFreeTickets = 0; // Number of tickets held by non-scheduled threads
+tThread *gActiveThreads = NULL; // Currently Running Threads
+#elif SCHEDULER_TYPE == SCHED_RR_SIM
+tThread *gActiveThreads = NULL; // Currently Running Threads
+#elif SCHEDULER_TYPE == SCHED_RR_PRI
+tThread *gaActiveThreads[MIN_PRIORITY+1]; // Active threads for each priority level
+#else
+# error "Unkown scheduler type"
+#endif
// === CODE ===
/**
ArchThreads_Init();
// Create Initial Task
+ #if SCHEDULER_TYPE == SCHED_RR_PRI
+ gaActiveThreads[gThreadZero.Priority] = &gThreadZero;
+ #else
gActiveThreads = &gThreadZero;
+ #endif
+
gAllThreads = &gThreadZero;
- //giFreeTickets = gThreadZero.NumTickets; // Not needed, as ThreadZero is scheduled
giNumActiveThreads = 1;
Proc_Start();
}
/**
- * \fn void Threads_SetName(char *NewName)
+ * \fn void Threads_SetName(const char *NewName)
* \brief Sets the current thread's name
* \param NewName New name for the thread
* \return Boolean Failure
*/
-int Threads_SetName(char *NewName)
+int Threads_SetName(const char *NewName)
{
tThread *cur = Proc_GetCurThread();
char *oldname = cur->ThreadName;
}
/**
- * \fn void Threads_SetTickets(tThread *Thread, int Num)
- * \brief Sets the 'priority' of a task
+ * \fn void Threads_SetPriority(tThread *Thread, int Pri)
+ * \brief Sets the priority of a task
* \param Thread Thread to update ticket count (NULL means current thread)
- * \param Num New ticket count (must be >= 0, clipped to \a MAX_TICKETS)
+ * \param Pri New priority
*/
-void Threads_SetTickets(tThread *Thread, int Num)
+void Threads_SetPriority(tThread *Thread, int Pri)
{
// Get current thread
if(Thread == NULL) Thread = Proc_GetCurThread();
// Bounds checking
- if(Num < 0) return;
- if(Num > MAX_TICKETS) Num = MAX_TICKETS;
+ // - If < 0, set to lowest priority
+ if(Pri < 0) Pri = MIN_PRIORITY;
+ if(Pri > MIN_PRIORITY) Pri = MIN_PRIORITY;
+ // Do we actually have to do anything?
+ if( Pri == Thread->Priority ) return;
+
+ #if SCHEDULER_TYPE == SCHED_RR_PRI
+ SHORTLOCK( &glThreadListLock );
+ // Remove from old priority
+ Threads_int_DelFromQueue( &gaActiveThreads[Thread->Priority], Thread );
+ // And add to new
+ Thread->Next = gaActiveThreads[Pri];
+ gaActiveThreads[Pri] = Thread;
+ Thread->Priority = Pri;
+ SHORTREL( &glThreadListLock );
+ #else
// If this isn't the current thread, we need to lock
- if( Thread != Proc_GetCurThread() ) {
+ if( Thread != Proc_GetCurThread() )
+ {
SHORTLOCK( &glThreadListLock );
- giFreeTickets -= Thread->NumTickets - Num;
- Thread->NumTickets = Num;
- #if DEBUG_TRACE_TICKETS
+
+ #if SCHEDULER_TYPE == SCHED_LOTTERY
+ giFreeTickets -= caiTICKET_COUNTS[Thread->Priority] - caiTICKET_COUNTS[Pri];
+ # if DEBUG_TRACE_TICKETS
Log("Threads_SetTickets: new giFreeTickets = %i", giFreeTickets);
+ # endif
#endif
+ Thread->Priority = Pri;
SHORTREL( &glThreadListLock );
}
else
- Thread->NumTickets = Num;
+ Thread->Priority = Pri;
+ #endif
}
/**
// Set State
new->Remaining = new->Quantum = cur->Quantum;
- new->NumTickets = cur->NumTickets;
+ new->Priority = cur->Priority;
// Set Signal Handlers
new->CurFaultNum = 0;
}
/**
- * \brief Gets the previous entry in a thead linked list
+ * \brief Deletes an entry from a list
* \param List Pointer to the list head
* \param Thread Thread to find
- * \return Thread before \a Thread on \a List
- * \note This uses a massive hack of assuming that the first field in the
- * structure is the .Next pointer. By doing this, we can return \a List
- * as a (tThread*) and simplify other code.
+ * \return \a Thread
*/
-tThread *Threads_int_GetPrev(tThread **List, tThread *Thread)
+tThread *Threads_int_DelFromQueue(tThread **List, tThread *Thread)
{
- tThread *ret;
- // First Entry
- if(*List == Thread) {
- return (tThread*)List;
+ tThread *ret, *prev = NULL;
+
+ for(ret = *List;
+ ret && ret != Thread;
+ prev = ret, ret = ret->Next
+ );
+
+ // Is the thread on the list
+ if(!ret) {
+ //LogF("%p(%s) is not on list %p\n", Thread, Thread->ThreadName, List);
+ return NULL;
+ }
+
+ if( !prev ) {
+ *List = Thread->Next;
+ //LogF("%p(%s) removed from head of %p\n", Thread, Thread->ThreadName, List);
}
- // Or not
else {
- for(ret = *List;
- ret->Next && ret->Next != Thread;
- ret = ret->Next
- );
- // Error if the thread is not on the list
- if(!ret->Next || ret->Next != Thread) {
- return NULL;
- }
+ prev->Next = Thread->Next;
+ //LogF("%p(%s) removed from %p (prev=%p)\n", Thread, Thread->ThreadName, List, prev);
}
- return ret;
+
+ return Thread;
}
/**
*/
void Threads_Kill(tThread *Thread, int Status)
{
- tThread *prev;
tMsg *msg;
// TODO: Kill all children
// Lock thread list
SHORTLOCK( &glThreadListLock );
- // Get previous thread on list
- prev = Threads_int_GetPrev( &gActiveThreads, Thread );
- if(!prev) {
+ // Delete from active list
+ #if SCHEDULER_TYPE == SCHED_RR_PRI
+ if( !Threads_int_DelFromQueue( &gaActiveThreads[Thread->Priority], Thread ) )
+ #else
+ if( !Threads_int_DelFromQueue( &gActiveThreads, Thread ) )
+ #endif
+ {
Warning("Proc_Exit - Current thread is not on the active queue");
SHORTREL( &glThreadListLock );
SHORTREL( &Thread->IsLocked );
// Ensure that we are not rescheduled
Thread->Remaining = 0; // Clear Remaining Quantum
Thread->Quantum = 0; // Clear Quantum to indicate dead thread
- prev->Next = Thread->Next; // Remove from active
// Update bookkeeping
giNumActiveThreads --;
+ #if SCHEDULER_TYPE == SCHED_LOTTERY
if( Thread != Proc_GetCurThread() )
- giFreeTickets -= Thread->NumTickets;
+ giFreeTickets -= caiTICKET_COUNTS[ Thread->Priority ];
+ #endif
// Save exit status
Thread->RetStatus = Status;
*/
int Threads_Wake(tThread *Thread)
{
- tThread *prev;
-
if(!Thread)
return -EINVAL;
case THREAD_STAT_SLEEPING:
SHORTLOCK( &glThreadListLock );
// Remove from sleeping queue
- prev = Threads_int_GetPrev(&gSleepingThreads, Thread);
- prev->Next = Thread->Next;
+ Threads_int_DelFromQueue(&gSleepingThreads, Thread);
Threads_AddActive( Thread );
{
SHORTLOCK( &glThreadListLock );
- #if 1
- {
- tThread *t;
- for( t = gActiveThreads; t; t = t->Next )
- {
- if( t == Thread ) {
- Panic("Threads_AddActive: Attempting a double add of TID %i (0x%x)",
- Thread->TID, __builtin_return_address(0));
- }
-
- if(t->Status != THREAD_STAT_ACTIVE) {
- Panic("Threads_AddActive: TID %i status != THREAD_STAT_ACTIVE",
- Thread->TID);
- }
- }
+ if( Thread->Status == THREAD_STAT_ACTIVE ) {
+ tThread *cur = Proc_GetCurThread();
+ Warning("WTF, CPU%i %p (%i %s) is adding %p (%i %s) when it is active",
+ GetCPUNum(), cur, cur->TID, cur->ThreadName, Thread, Thread->TID, Thread->ThreadName);
}
- #endif
- // Add to active list
- Thread->Next = gActiveThreads;
- gActiveThreads = Thread;
// Set state
Thread->Status = THREAD_STAT_ACTIVE;
Thread->CurCPU = -1;
+ // Add to active list
+ #if SCHEDULER_TYPE == SCHED_RR_PRI
+ Thread->Next = gaActiveThreads[Thread->Priority];
+ gaActiveThreads[Thread->Priority] = Thread;
+ #else
+ Thread->Next = gActiveThreads;
+ gActiveThreads = Thread;
+ #endif
// Update bookkeeping
giNumActiveThreads ++;
- giFreeTickets += Thread->NumTickets;
- #if DEBUG_TRACE_TICKETS
- Log("Threads_AddActive: %p %i (%s) added, new giFreeTickets = %i",
- Thread, Thread->TID, Thread->ThreadName, giFreeTickets);
+ #if SCHEDULER_TYPE == SCHED_LOTTERY
+ giFreeTickets += caiTICKET_COUNTS[ Thread->Priority ];
+ # if DEBUG_TRACE_TICKETS
+ Log("Threads_AddActive: CPU%i %p %i (%s) added, new giFreeTickets = %i",
+ GetCPUNum(), Thread, Thread->TID, Thread->ThreadName, giFreeTickets);
+ # endif
#endif
+
SHORTREL( &glThreadListLock );
}
tThread *Threads_RemActive(void)
{
tThread *ret = Proc_GetCurThread();
- tThread *prev;
SHORTLOCK( &glThreadListLock );
- prev = Threads_int_GetPrev(&gActiveThreads, ret);
- if(!prev) {
+ // Delete from active queue
+ #if SCHEDULER_TYPE == SCHED_RR_PRI
+ if( !Threads_int_DelFromQueue(&gaActiveThreads[ret->Priority], ret) )
+ #else
+ if( !Threads_int_DelFromQueue(&gActiveThreads, ret) )
+ #endif
+ {
SHORTREL( &glThreadListLock );
return NULL;
}
+ ret->Next = NULL;
ret->Remaining = 0;
ret->CurCPU = -1;
- prev->Next = ret->Next;
giNumActiveThreads --;
// no need to decrement tickets, scheduler did it for us
- #if DEBUG_TRACE_TICKETS
- Log("Threads_RemActive: %p %i (%s) removed, giFreeTickets = %i",
- ret, ret->TID, ret->ThreadName, giFreeTickets);
+ #if SCHEDULER_TYPE == SCHED_LOTTERY && DEBUG_TRACE_TICKETS
+ Log("Threads_RemActive: CPU%i %p %i (%s) removed, giFreeTickets = %i",
+ GetCPUNum(), ret, ret->TID, ret->ThreadName, giFreeTickets);
#endif
SHORTREL( &glThreadListLock );
/**
* \fn void Threads_Dump(void)
- * \brief Dumps a list of currently running threads
*/
-void Threads_Dump(void)
+void Threads_DumpActive(void)
{
tThread *thread;
+ #if SCHEDULER_TYPE == SCHED_RR_PRI
+ int i;
+ #endif
- Log("--- Thread Dump ---");
Log("Active Threads: (%i reported)", giNumActiveThreads);
- for(thread=gActiveThreads;thread;thread=thread->Next)
- {
- Log(" %i (%i) - %s (CPU %i)",
- thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU);
- if(thread->Status != THREAD_STAT_ACTIVE)
- Log(" ERROR State (%i) != THREAD_STAT_ACTIVE (%i)", thread->Status, THREAD_STAT_ACTIVE);
- Log(" %i Tickets, Quantum %i", thread->NumTickets, thread->Quantum);
- Log(" KStack 0x%x", thread->KernelStack);
- }
- Log("All Threads:");
- for(thread=gAllThreads;thread;thread=thread->GlobalNext)
+ #if SCHEDULER_TYPE == SCHED_RR_PRI
+ for( i = 0; i < MIN_PRIORITY+1; i++ )
{
- Log(" %i (%i) - %s (CPU %i)",
- thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU);
- Log(" State %i", thread->Status);
- Log(" %i Tickets, Quantum %i", thread->NumTickets, thread->Quantum);
- Log(" KStack 0x%x", thread->KernelStack);
+ for(thread=gaActiveThreads[i];thread;thread=thread->Next)
+ #else
+ for(thread=gActiveThreads;thread;thread=thread->Next)
+ #endif
+ {
+ Log(" %p %i (%i) - %s (CPU %i)",
+ thread, thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU);
+ if(thread->Status != THREAD_STAT_ACTIVE)
+ Log(" ERROR State (%i) != THREAD_STAT_ACTIVE (%i)", thread->Status, THREAD_STAT_ACTIVE);
+ Log(" Priority %i, Quantum %i", thread->Priority, thread->Quantum);
+ Log(" KStack 0x%x", thread->KernelStack);
+ }
+
+ #if SCHEDULER_TYPE == SCHED_RR_PRI
}
+ #endif
}
+
/**
* \fn void Threads_Dump(void)
+ * \brief Dumps a list of currently running threads
*/
-void Threads_DumpActive(void)
+void Threads_Dump(void)
{
tThread *thread;
- Log("Active Threads:");
- for(thread=gActiveThreads;thread;thread=thread->Next)
+ Log("--- Thread Dump ---");
+ Threads_DumpActive();
+
+ Log("All Threads:");
+ for(thread=gAllThreads;thread;thread=thread->GlobalNext)
{
- Log(" %i (%i) - %s (CPU %i)",
- thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU);
- if(thread->Status != THREAD_STAT_ACTIVE)
- Log(" ERROR State (%i) != THREAD_STAT_ACTIVE (%i)", thread->Status, THREAD_STAT_ACTIVE);
- Log(" %i Tickets, Quantum %i", thread->NumTickets, thread->Quantum);
+ Log(" %p %i (%i) - %s (CPU %i)",
+ thread, thread->TID, thread->TGID, thread->ThreadName, thread->CurCPU);
+ Log(" State %i (%s)", thread->Status, casTHREAD_STAT[thread->Status]);
+ switch(thread->Status)
+ {
+ case THREAD_STAT_MUTEXSLEEP:
+ Log(" Mutex Pointer: %p", thread->WaitPointer);
+ break;
+ case THREAD_STAT_ZOMBIE:
+ Log(" Return Status: %i", thread->RetStatus);
+ break;
+ default: break;
+ }
+ Log(" Priority %i, Quantum %i", thread->Priority, thread->Quantum);
Log(" KStack 0x%x", thread->KernelStack);
}
}
tThread *Threads_GetNextToRun(int CPU, tThread *Last)
{
tThread *thread;
- int ticket;
- int number;
// If this CPU has the lock, we must let it complete
if( CPU_HAS_LOCK( &glThreadListLock ) )
return Last;
- // Same if the current CPU has any lock
+ // Don't change threads if the current CPU has switches disabled
if( gaThreads_NoTaskSwitch[CPU] )
return Last;
thread = gDeleteThreads->Next;
if( IS_LOCKED(&gDeleteThreads->IsLocked) ) { // Only free if structure is unused
// Set to dead
- gDeleteThreads->Status = THREAD_STAT_DEAD;
+ gDeleteThreads->Status = THREAD_STAT_BURIED;
// Free name
if( IsHeap(gDeleteThreads->ThreadName) )
free(gDeleteThreads->ThreadName);
return NULL;
}
+ #if SCHEDULER_TYPE != SCHED_RR_PRI
// Special case: 1 thread
if(giNumActiveThreads == 1) {
if( gActiveThreads->CurCPU == -1 )
return NULL; // CPU has nothing to do
}
+ #endif
// Allow the old thread to be scheduled again
if( Last ) {
if( Last->Status == THREAD_STAT_ACTIVE ) {
- giFreeTickets += Last->NumTickets;
- #if DEBUG_TRACE_TICKETS
+ #if SCHEDULER_TYPE == SCHED_LOTTERY
+ giFreeTickets += caiTICKET_COUNTS[ Last->Priority ];
+ # if DEBUG_TRACE_TICKETS
LogF(" CPU %i released %p (%i %s) into the pool (%i tickets in pool)\n",
CPU, Last, Last->TID, Last->ThreadName, giFreeTickets);
+ # endif
#endif
}
- #if DEBUG_TRACE_TICKETS
+ #if SCHEDULER_TYPE == SCHED_LOTTERY && DEBUG_TRACE_TICKETS
else
- LogF(" CPU %i released %p (%s)->Status = %i (Released)\n",
- CPU, Last, Last->ThreadName, Last->Status);
+ LogF(" CPU %i released %p (%i %s)->Status = %i (Released)\n",
+ CPU, Last, Last->TID, Last->ThreadName, Last->Status);
#endif
Last->CurCPU = -1;
}
- #if DEBUG_TRACE_TICKETS
- //Threads_DumpActive();
- #endif
-
- #if 1
- number = 0;
- for(thread = gActiveThreads; thread; thread = thread->Next) {
- if(thread->CurCPU >= 0) continue;
- if(thread->Status != THREAD_STAT_ACTIVE)
- Panic("Bookkeeping fail - %p %i(%s) is on the active queue with a status of %i",
- thread, thread->TID, thread->ThreadName, thread->Status);
- if(thread->Next == thread) {
- Panic("Bookkeeping fail - %p %i(%s) loops back on itself",
- thread, thread->TID, thread->ThreadName, thread->Status);
+ // ---
+ // Lottery Scheduler
+ // ---
+ #if SCHEDULER_TYPE == SCHED_LOTTERY
+ {
+ int ticket, number;
+ # if 1
+ number = 0;
+ for(thread = gActiveThreads; thread; thread = thread->Next) {
+ if(thread->CurCPU >= 0) continue;
+ if(thread->Status != THREAD_STAT_ACTIVE)
+ Panic("Bookkeeping fail - %p %i(%s) is on the active queue with a status of %i",
+ thread, thread->TID, thread->ThreadName, thread->Status);
+ if(thread->Next == thread) {
+ Panic("Bookkeeping fail - %p %i(%s) loops back on itself",
+ thread, thread->TID, thread->ThreadName, thread->Status);
+ }
+ number += caiTICKET_COUNTS[ thread->Priority ];
}
- number += thread->NumTickets;
- }
- if(number != giFreeTickets) {
- Panic("Bookkeeping fail (giFreeTickets(%i) != number(%i)) - CPU%i",
- giFreeTickets, number, CPU);
- }
- #endif
-
- // No free tickets (all tasks delegated to cores)
- if( giFreeTickets == 0 ) {
- SHORTREL(&glThreadListLock);
- return NULL;
+ if(number != giFreeTickets) {
+ Panic("Bookkeeping fail (giFreeTickets(%i) != number(%i)) - CPU%i",
+ giFreeTickets, number, CPU);
+ }
+ # endif
+
+ // No free tickets (all tasks delegated to cores)
+ if( giFreeTickets == 0 ) {
+ SHORTREL(&glThreadListLock);
+ return NULL;
+ }
+
+ // Get the ticket number
+ ticket = number = rand() % giFreeTickets;
+
+ // Find the next thread
+ for(thread=gActiveThreads;thread;thread=thread->Next)
+ {
+ if(thread->CurCPU >= 0) continue;
+ if( caiTICKET_COUNTS[ thread->Priority ] > number) break;
+ number -= caiTICKET_COUNTS[ thread->Priority ];
+ }
+
+ // If we didn't find a thread, something went wrong
+ if(thread == NULL)
+ {
+ number = 0;
+ for(thread=gActiveThreads;thread;thread=thread->Next) {
+ if(thread->CurCPU >= 0) continue;
+ number += caiTICKET_COUNTS[ thread->Priority ];
+ }
+ Panic("Bookeeping Failed - giFreeTickets(%i) > true count (%i)",
+ giFreeTickets, number);
+ }
+ # if DEBUG_TRACE_TICKETS
+ LogF(" CPU%i giFreeTickets = %i, running %p (%i %s CPU=%i)\n",
+ CPU, giFreeTickets, thread, thread->TID, thread->ThreadName, thread->CurCPU);
+ # endif
+
+ giFreeTickets -= caiTICKET_COUNTS[ thread->Priority ];
}
- // Get the ticket number
- ticket = number = rand() % giFreeTickets;
-
- // Find the next thread
- for(thread=gActiveThreads;thread;thread=thread->Next)
+ // ---
+ // Priority based round robin scheduler
+ // ---
+ #elif SCHEDULER_TYPE == SCHED_RR_PRI
{
- if(thread->CurCPU >= 0) continue;
- if(thread->NumTickets > number) break;
- number -= thread->NumTickets;
+ int i;
+ for( i = 0; i < MIN_PRIORITY + 1; i ++ )
+ {
+ for(thread = gaActiveThreads[i]; thread; thread = thread->Next)
+ {
+ if( thread->CurCPU == -1 ) break;
+ }
+ // If we fall onto the same queue again, special handling is
+ // needed
+ if( i == Last->Priority ) {
+ tThread *savedThread = thread;
+
+ // Find the next unscheduled thread in the list
+ for( thread = Last->Next; thread; thread = thread->Next )
+ {
+ if( thread->CurCPU == -1 ) break;
+ }
+ // If we don't find anything after, just use the one
+ // found above.
+ if( !thread ) thread = savedThread;
+ }
+ // Found a thread? Schedule it!
+ if( thread ) break;
+ }
+
+ // Anything to do?
+ if( !thread ) {
+ SHORTREL(&glThreadListLock);
+ return NULL;
+ }
}
- // Error Check
- if(thread == NULL)
- {
- number = 0;
- for(thread=gActiveThreads;thread;thread=thread->Next) {
- if(thread->CurCPU >= 0) continue;
- number += thread->NumTickets;
+ #elif SCHEDULER_TYPE == SCHED_RR_SIM
+ {
+ // Find the next unscheduled thread in the list
+ for( thread = Last->Next; thread; thread = thread->Next )
+ {
+ if( thread->CurCPU == -1 ) break;
+ }
+ // If we don't find anything after, search from the beginning
+ if( !thread )
+ {
+ for(thread = gActiveThreads; thread; thread = thread->Next)
+ {
+ if( thread->CurCPU == -1 ) break;
+ }
+ }
+
+ // Anything to do?
+ if( !thread ) {
+ SHORTREL(&glThreadListLock);
+ return NULL;
}
- Panic("Bookeeping Failed - giFreeTickets(%i) > true count (%i)",
- giFreeTickets, number);
}
- #if DEBUG_TRACE_TICKETS
- LogF(" CPU%i giFreeTickets = %i\n", CPU, giFreeTickets);
+ #else
+ # error "Unimplemented scheduling algorithm"
#endif
// Make the new thread non-schedulable
- giFreeTickets -= thread->NumTickets;
thread->CurCPU = CPU;
- //Threads_Dump();
- #if DEBUG_TRACE_TICKETS
- LogF(" CPU%i giFreeTickets = %i, giving %p (%i %s CPU=%i)\n",
- CPU, giFreeTickets, thread, thread->TID, thread->ThreadName, thread->CurCPU);
- #endif
-
SHORTREL( &glThreadListLock );
return thread;
if( Mutex->Owner ) {
SHORTLOCK( &glThreadListLock );
// - Remove from active list
- Threads_RemActive();
+ us = Threads_RemActive();
+ us->Next = NULL;
// - Mark as sleeping
- us->Status = THREAD_STAT_OFFSLEEP;
+ us->Status = THREAD_STAT_MUTEXSLEEP;
+ us->WaitPointer = Mutex;
// - Add to waiting
if(Mutex->LastWaiting) {
Mutex->Waiting = us;
Mutex->LastWaiting = us;
}
+ #if 0
+ {
+ int i = 0;
+ tThread *t;
+ for( t = Mutex->Waiting; t; t = t->Next, i++ )
+ Log("[%i] (tMutex)%p->Waiting[%i] = %p (%i %s)", us->TID, Mutex, i,
+ t, t->TID, t->ThreadName);
+ }
+ #endif
+
SHORTREL( &glThreadListLock );
SHORTREL( &Mutex->Protector );
- while(us->Status == THREAD_STAT_OFFSLEEP) Threads_Yield();
+ while(us->Status == THREAD_STAT_MUTEXSLEEP) Threads_Yield();
// We're only woken when we get the lock
+ us->WaitPointer = NULL;
}
// Ooh, let's take it!
else {
Mutex->Owner = us;
SHORTREL( &Mutex->Protector );
}
+
+ #if 0
+ extern tMutex glPhysAlloc;
+ if( Mutex != &glPhysAlloc )
+ LogF("Mutex %p taken by %i %p\n", Mutex, us->TID, __builtin_return_address(0));
+ #endif
}
/**
if( Mutex->Waiting ) {
Mutex->Owner = Mutex->Waiting; // Set owner
Mutex->Waiting = Mutex->Waiting->Next; // Next!
+ // Reset ->LastWaiting to NULL if we have just removed the last waiting thread
+ // 2010-10-02 21:50 - Comemerating the death of the longest single
+ // blocker in the Acess2 history. REMEMBER TO
+ // FUCKING MAINTAIN YOUR FUCKING LISTS DIPWIT
+ if( Mutex->LastWaiting == Mutex->Owner )
+ Mutex->LastWaiting = NULL;
// Wake new owner
SHORTLOCK( &glThreadListLock );
Mutex->Owner = NULL;
}
SHORTREL( &Mutex->Protector );
+
+ #if 0
+ extern tMutex glPhysAlloc;
+ if( Mutex != &glPhysAlloc )
+ LogF("Mutex %p released by %i %p\n", Mutex, Threads_GetTID(), __builtin_return_address(0));
+ #endif
}
/**
return Mutex->Owner != NULL;
}
+/**
+ * \brief Initialise the semaphore
+ * \param Value Initial value of the semaphore
+ * \param Label Symbolic name
+ */
+void Semaphore_Init(tSemaphore *Sem, int Value, const char *Label)
+{
+ Sem->Value = Value;
+ Sem->Name = Label;
+}
+
+/**
+ * \brief Acquire a "item" from the semaphore
+ */
+void Semaphore_Wait(tSemaphore *Sem)
+{
+ tThread *us;
+
+ SHORTLOCK( &Sem->Protector );
+ if( Sem->Value > 0 ) {
+ Sem->Value --;
+ SHORTREL( &Sem->Protector );
+ return ;
+ }
+
+ SHORTLOCK( &glThreadListLock );
+
+ // - Remove from active list
+ us = Threads_RemActive();
+ us->Next = NULL;
+ // - Mark as sleeping
+ us->Status = THREAD_STAT_SEMAPHORESLEEP;
+ us->WaitPointer = Sem;
+
+ // - Add to waiting
+ if(Sem->LastWaiting) {
+ Sem->LastWaiting->Next = us;
+ Sem->LastWaiting = us;
+ }
+ else {
+ Sem->Waiting = us;
+ Sem->LastWaiting = us;
+ }
+
+ SHORTREL( &glThreadListLock );
+ SHORTREL( &Sem->Protector );
+ while(us->Status == THREAD_STAT_MUTEXSLEEP) Threads_Yield();
+ // We're only woken when there's something avaliable
+ us->WaitPointer = NULL;
+}
+
+/**
+ * \brief Add an "item" to the semaphore
+ */
+void Semaphore_Signal(tSemaphore *Sem)
+{
+ SHORTLOCK( &Sem->Protector );
+ Sem->Value ++;
+
+ if( Sem->Waiting )
+ {
+ tThread *toWake = Sem->Waiting;
+
+ Sem->Waiting = Sem->Waiting->Next; // Next!
+ // Reset ->LastWaiting to NULL if we have just removed the last waiting thread
+ if( Sem->Waiting == NULL )
+ Sem->LastWaiting = NULL;
+
+ // Wake new owner
+ SHORTLOCK( &glThreadListLock );
+ if( toWake->Status != THREAD_STAT_ACTIVE )
+ Threads_AddActive(toWake);
+ SHORTREL( &glThreadListLock );
+
+ // Decrement (the value is now "owned" by `toWake`)
+ Sem->Value --;
+ }
+ SHORTREL( &Sem->Protector );
+}
+
// === EXPORTS ===
EXPORT(Threads_GetUID);
+EXPORT(Threads_GetGID);
EXPORT(Mutex_Acquire);
EXPORT(Mutex_Release);
EXPORT(Mutex_IsLocked);
git.ucc.asn.au / tpg / acess2.git / blobdiff
UCC git Repository :: git.ucc.asn.au