#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
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);
void Threads_Sleep(void);
int Threads_Wake(tThread *Thread);
void Threads_AddActive(tThread *Thread);
-void Threads_int_AddActive(tThread *Thread);
tThread *Threads_RemActive(void);
int Threads_GetPID(void);
int Threads_GetTID(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_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 (stop us recieving messages)
SHORTLOCK( &Thread->IsLocked );
+ // Clear Message Queue
+ while( Thread->Messages )
+ {
+ msg = Thread->Messages->Next;
+ free( Thread->Messages );
+ Thread->Messages = msg;
+ }
+
// 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 );
return;
}
- // Clear Message Queue
- while( Thread->Messages )
- {
- msg = Thread->Messages->Next;
- free( Thread->Messages ); // BIG NO-NO
- Thread->Messages = msg;
- }
-
// 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;
return -EALREADY;
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_int_AddActive( Thread );
+ Threads_AddActive( Thread );
#if DEBUG_TRACE_STATE
Log("Threads_Sleep: %p (%i %s) woken", Thread, Thread->TID, Thread->ThreadName);
#endif
+ SHORTREL( &glThreadListLock );
return -EOK;
case THREAD_STAT_WAITING:
int ret;
if(!thread)
return -ENOENT;
- SHORTLOCK( &glThreadListLock );
ret = Threads_Wake( thread );
- SHORTREL( &glThreadListLock );
//Log_Debug("Threads", "TID %i woke %i (%p)", Threads_GetTID(), TID, thread);
return ret;
}
void Threads_AddActive(tThread *Thread)
{
SHORTLOCK( &glThreadListLock );
- Threads_int_AddActive(Thread);
- SHORTREL( &glThreadListLock );
-}
-
-/**
- * \brief Adds a thread to the active queue
- * \note This version MUST have the thread list lock held
- */
-void Threads_int_AddActive(tThread *Thread)
-{
- // 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_int_AddActive: new giFreeTickets = %i", giFreeTickets);
+ #if SCHEDULER_TYPE == SCHED_LOTTERY
+ giFreeTickets += caiTICKET_COUNTS[ Thread->Priority ];
+ # if DEBUG_TRACE_TICKETS
+ Log("Threads_AddActive: %p %i (%s) added, new giFreeTickets = %i",
+ Thread, Thread->TID, Thread->ThreadName, giFreeTickets);
+ # endif
#endif
+
+ SHORTREL( &glThreadListLock );
}
/**
tThread *Threads_RemActive(void)
{
tThread *ret = Proc_GetCurThread();
- tThread *prev = Threads_int_GetPrev(&gActiveThreads, ret);
- if(!prev) return NULL;
+
+ SHORTLOCK( &glThreadListLock );
+
+ // 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->Remaining = 0;
ret->CurCPU = -1;
- prev->Next = ret->Next;
+
giNumActiveThreads --;
+ // no need to decrement tickets, scheduler did it for us
+
+ #if SCHEDULER_TYPE == SCHED_LOTTERY && DEBUG_TRACE_TICKETS
+ Log("Threads_RemActive: %p %i (%s) removed, giFreeTickets = %i",
+ ret, ret->TID, ret->ThreadName, giFreeTickets);
+ #endif
+
+ SHORTREL( &glThreadListLock );
+
return ret;
}
/**
* \fn void Threads_Dump(void)
- * \brief Dums 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("Active Threads: (%i reported)", giNumActiveThreads);
- Log("Active Threads:");
- for(thread=gActiveThreads;thread;thread=thread->Next)
+ #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);
- 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);
+ for(thread=gaActiveThreads[i];thread;thread=thread->Next)
+ #else
+ for(thread=gActiveThreads;thread;thread=thread->Next)
+ #endif
+ {
+ 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(" 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_Dump(void)
+{
+ tThread *thread;
+
+ 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);
Log(" State %i", thread->Status);
- Log(" %i Tickets, Quantum %i", thread->NumTickets, thread->Quantum);
+ 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;
+
+ // Don't change threads if the current CPU has switches disabled
+ if( gaThreads_NoTaskSwitch[CPU] )
+ return Last;
+
+
// Lock thread list
SHORTLOCK( &glThreadListLock );
return NULL;
}
+ #if SCHEDULER_TYPE != SCHED_RR_PRI
// Special case: 1 thread
if(giNumActiveThreads == 1) {
if( gActiveThreads->CurCPU == -1 )
gActiveThreads->CurCPU = CPU;
+
SHORTREL( &glThreadListLock );
+
if( gActiveThreads->CurCPU == CPU )
return gActiveThreads;
+
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(" %p (%s)->Status = %i (Released)\n", 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 1
- number = 0;
- for(thread = gActiveThreads; thread; thread = thread->Next) {
- if(thread->CurCPU >= 0) continue;
- 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;
+ // ---
+ // 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 ];
+ }
+ 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();
// - Mark as sleeping
us->Status = THREAD_STAT_OFFSLEEP;
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
- Threads_AddActive(Mutex->Owner);
- //Log("Mutex %p Woke %p", Mutex, Mutex->Owner);
+ SHORTLOCK( &glThreadListLock );
+ if( Mutex->Owner->Status != THREAD_STAT_ACTIVE )
+ Threads_AddActive(Mutex->Owner);
+ SHORTREL( &glThreadListLock );
}
else {
Mutex->Owner = NULL;
// === 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