Decompiles sched.c (#145)

* decompile sched.c

* rename Game_AllocEnd to Game_Alloc in z_effect_soft_sprite.c

* pr updates

18 files changed, 485 insertions, 73 deletions

diff --git a/src/code/audioMgr.c b/src/code/audioMgr.c
index e87813503..cdec774cb 100644
--- a/src/code/audioMgr.c
+++ b/src/code/audioMgr.c
@@ -26,7 +26,7 @@ void AudioMgr_HandleRetrace(AudioMgr* audioMgr) {
 
         audioMgr->unk_5C = NULL;
         osSendMesg(&audioMgr->sched->cmdQ, &audioMgr->unk_8, OS_MESG_BLOCK);
-        func_800C95F8(audioMgr->sched);
+        Sched_SendEntryMsg(audioMgr->sched);
     }
     D_8016A550 = osGetTime();
     if (SREG(20) >= 2) {
diff --git a/src/code/game.c b/src/code/game.c
index 7bbfb965a..7a29a081a 100644
--- a/src/code/game.c
+++ b/src/code/game.c
@@ -496,7 +496,7 @@ u32 GameState_IsRunning(GameState* gameState) {
     return gameState->running;
 }
 
-void* GameState_AllocEnd(GameState* gameState, size_t size, char* file, s32 line) {
+void* GameState_Alloc(GameState* gameState, size_t size, char* file, s32 line) {
     void* ret;
 
     if (THA_IsCrash(&gameState->tha)) {
diff --git a/src/code/graph.c b/src/code/graph.c
index e8c5a6393..eab22cd5c 100644
--- a/src/code/graph.c
+++ b/src/code/graph.c
@@ -244,7 +244,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
 
     cfb = sGraphCfbInfos + sGraphCfbInfoIdx++;
     cfb->fb1 = gfxCtx->curFrameBuffer;
-    cfb->swapbuffer = gfxCtx->curFrameBuffer;
+    cfb->swapBuffer = gfxCtx->curFrameBuffer;
     cfb->viMode = gfxCtx->viMode;
     cfb->features = gfxCtx->viFeatures;
     cfb->xScale = gfxCtx->xScale;
@@ -257,7 +257,7 @@ void Graph_TaskSet00(GraphicsContext* gfxCtx) {
     gfxCtx->schedMsgQ = &gSchedContext.cmdQ;
 
     osSendMesg(&gSchedContext.cmdQ, scTask, OS_MESG_BLOCK);
-    func_800C95F8(&gSchedContext); // osScKickEntryMsg
+    Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg
 }
 #else
 u32 D_8012D260 = 0;
@@ -374,12 +374,12 @@ void Graph_Update(GraphicsContext* gfxCtx, GameState* gameState) {
 
     func_800F3054();
     time = osGetTime();
-    D_8016A538 = D_8016A568;
-    D_8016A530 = D_8016A560;
-    D_8016A540 = D_8016A580;
-    D_8016A568 = 0;
-    D_8016A560 = 0;
-    D_8016A580 = 0;
+    D_8016A538 = gRSPGFXTotalTime;
+    D_8016A530 = gRSPAudioTotalTime;
+    D_8016A540 = gRDPTotalTime;
+    gRSPGFXTotalTime = 0;
+    gRSPAudioTotalTime = 0;
+    gRDPTotalTime = 0;
 
     if (sGraphUpdateTime != 0) {
         D_8016A548 = time - sGraphUpdateTime;
diff --git a/src/code/main.c b/src/code/main.c
index 3b4abac43..6e0862287 100644
--- a/src/code/main.c
+++ b/src/code/main.c
@@ -79,7 +79,7 @@ void Main(void* arg0) {
 
     osSyncPrintf("タスクスケジューラの初期化\n"); // Initialize the task scheduler
     StackCheck_Init(&sSchedStackInfo, sSchedStack, sSchedStack + sizeof(sSchedStack), 0, 0x100, "sched");
-    func_800C9874(&gSchedContext, &sAudioStack, 0xf, D_80013960, 1, &gIrqMgr);
+    Sched_Init(&gSchedContext, &sAudioStack, 0xf, D_80013960, 1, &gIrqMgr);
 
     IrqMgr_AddClient(&gIrqMgr, &irqClient, &irqMgrMsgQ);
 
diff --git a/src/code/sched.c b/src/code/sched.c
index a22b60ad2..ee91cfe6a 100644
--- a/src/code/sched.c
+++ b/src/code/sched.c
@@ -1,9 +1,59 @@
 #include <ultra64.h>
 #include <global.h>
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C82A0.s")
+#define RSP_DONE_MSG 667
+#define RDP_DONE_MSG 668
+#define ENTRY_MSG 670
 
-void func_800C84E4(SchedContext* sc, UNK_TYPE arg1) {
+// data
+volatile s32 sLogScheduler = false;
+
+// bss
+OSTime sRSPGFXStartTime;
+OSTime sRSPAudioStartTime;
+OSTime sRSPOtherStartTime;
+OSTime sRDPStartTime;
+
+void Sched_SwapFrameBuffer(CfbInfo* cfbInfo) {
+    u16 width;
+    LogUtils_CheckValidPointer("cfbinfo->swapbuffer", cfbInfo->swapBuffer, "../sched.c", 340);
+    if (cfbInfo->swapBuffer != NULL) {
+        osViSwapBuffer(cfbInfo->swapBuffer);
+        cfbInfo->updateRate2 = cfbInfo->updateRate;
+        if (sLogScheduler) {
+            osSyncPrintf("osViSwapBuffer %08x %08x %08x\n", osViGetCurrentFramebuffer(), osViGetNextFramebuffer(),
+                         (cfbInfo != NULL ? cfbInfo->swapBuffer : NULL));
+        }
+        width = cfbInfo->viMode != NULL ? cfbInfo->viMode->comRegs.width : gScreenWidth;
+        Fault_SetFB(cfbInfo->swapBuffer, width, 0x10);
+        if (HREG(80) == 0xD && HREG(95) != 0xD) {
+            HREG(81) = 0;
+            HREG(82) = 0;
+            HREG(83) = 1;
+            HREG(84) = 0;
+            HREG(85) = 1;
+            HREG(86) = 0;
+            HREG(87) = 0;
+            HREG(88) = 0;
+            HREG(89) = 0;
+            HREG(90) = 0;
+            HREG(91) = 0;
+            HREG(92) = 0;
+            HREG(93) = 0;
+            HREG(94) = 0;
+            HREG(95) = 0xD;
+        }
+        if (HREG(80) == 0xD && HREG(81) == 2) {
+            osViSetSpecialFeatures(HREG(82) != 0 ? 1 : 2);
+            osViSetSpecialFeatures(HREG(83) != 0 ? 0x40 : 0x80);
+            osViSetSpecialFeatures(HREG(84) != 0 ? 0x4 : 0x8);
+            osViSetSpecialFeatures(HREG(85) != 0 ? 0x10 : 0x20);
+        }
+    }
+    cfbInfo->unk_10 = 0;
+}
+
+void func_800C84E4(SchedContext* sc, CfbInfo* cfbInfo) {
     if (sc->unk_24C != 0) {
         sc->unk_24C = 0;
 
@@ -12,67 +62,189 @@ void func_800C84E4(SchedContext* sc, UNK_TYPE arg1) {
         }
     }
 
-    func_800C82A0(arg1);
+    Sched_SwapFrameBuffer(cfbInfo);
 }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8534.s")
+void Sched_HandleReset(SchedContext* sc) {
+    OSTime now;
+    if (sc->curRSPTask != NULL) {
+        now = osGetTime();
+        if (sc->curRSPTask->framebuffer == NULL) {
+            LOG_TIME("(((u64)(now - audio_rsp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
+                     OS_CYCLES_TO_USEC(now - sRSPAudioStartTime), "../sched.c", 421);
+        } else if (OS_CYCLES_TO_USEC(now - sRSPGFXStartTime) > 1000000 ||
+                   OS_CYCLES_TO_USEC(now - sRDPStartTime) > 1000000) {
+            func_800FBFD8();
+            if (sc->curRSPTask != NULL) {
+                LOG_TIME("(((u64)(now - graph_rsp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
+                         OS_CYCLES_TO_USEC(now - sRSPGFXStartTime), "../sched.c", 427);
+                osSendMesg(&sc->interruptQ, RSP_DONE_MSG, OS_MESG_NOBLOCK);
+            }
+            if (sc->curRDPTask != NULL) {
+                LOG_TIME("(((u64)(now - rdp_start_time)*(1000000LL/15625LL))/((62500000LL*3/4)/15625LL))",
+                         OS_CYCLES_TO_USEC(now - sRDPStartTime), "../sched.c", 431);
+                osSendMesg(&sc->interruptQ, RDP_DONE_MSG, 0);
+            }
+        }
+    }
+}
 
-void func_800C87CC(SchedContext* sc) {
+void Sched_HandleStart(SchedContext* sc) {
     ViConfig_UpdateVi(1);
 }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C87F0.s")
+void Sched_QueueTask(SchedContext* sc, OSScTask* task) {
+    s32 type = task->list.t.type;
+    if (!((type == M_AUDTASK) || (type == M_GFXTASK) || (type == M_NJPEGTASK) || (type == M_NULTASK))) {
+        __assert("(type == M_AUDTASK) || (type == M_GFXTASK) || (type == M_NJPEGTASK) || (type == M_NULTASK)",
+                 "../sched.c", 463);
+    }
+
+    if (type == M_AUDTASK) {
+        if (sLogScheduler) {
+            // You have entered an audio task
+            osSyncPrintf("オーディオタスクをエントリしました\n");
+        }
+        if (sc->audioListTail != NULL) {
+            sc->audioListTail->next = task;
+        } else {
+            sc->audioListHead = task;
+        }
+        sc->audioListTail = task;
+        sc->doAudio = 1;
+    } else {
+        if (sLogScheduler) {
+            // Entered graph task
+            osSyncPrintf("グラフタスクをエントリしました\n");
+        }
+
+        if (sc->gfxListTail != NULL) {
+            sc->gfxListTail->next = task;
+        } else {
+            sc->gfxListHead = task;
+        }
+        sc->gfxListTail = task;
+    }
+    task->next = NULL;
+    task->state = task->flags & (OS_SC_NEEDS_RDP | OS_SC_NEEDS_RSP);
+}
 
-void func_800C8910(SchedContext* sc) {
-    if (!(sc->curRSPTask->state & 0x10)) {
+void Sched_Yield(SchedContext* sc) {
+    if (!(sc->curRSPTask->state & OS_SC_YIELD)) {
         if (sc->curRSPTask->list.t.type == M_AUDTASK) {
             __assert("sc->curRSPTask->list.t.type != M_AUDTASK", "../sched.c", 496);
         }
 
-        sc->curRSPTask->state |= 0x10;
+        sc->curRSPTask->state |= OS_SC_YIELD;
 
         osSpTaskYield();
 
-        if (D_8012D290 != 0) {
+        if (sLogScheduler) {
             osSyncPrintf("%08d:osSpTaskYield\n", (u32)(OS_CYCLES_TO_USEC(osGetTime())));
         }
     }
 }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C89D4.s")
+OSScTask* func_800C89D4(SchedContext* sc, OSScTask* task) {
+    if (task == NULL) {
+        return NULL;
+    }
+
+    if (sc->pendingSwapBuf1 != NULL) {
+        if (0) {
+            __assert("sc->pending_swapbuffer1", "../sched.c", UNK_LINE);
+        }
+        return NULL;
+    }
+
+    if (sc->pendingSwapBuf2 != NULL) {
+        if (0) {
+            __assert("sc->pending_swapbuffer2", "../sched.c", UNK_LINE);
+        }
+        return NULL;
+    }
+
+    if ((sc->pendingSwapBuf2 != NULL ? sc->pendingSwapBuf2->swapBuffer : NULL) == task->framebuffer->fb1) {
+        return NULL;
+    }
+
+    if ((sc->pendingSwapBuf1 != NULL ? sc->pendingSwapBuf1->swapBuffer : NULL) == task->framebuffer->fb1) {
+        return NULL;
+    }
+
+    if (osViGetCurrentFramebuffer() == (u32*)task->framebuffer->fb1) {
+        return NULL;
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8A94.s")
+    return task;
+}
+
+#ifdef NON_MATCHING
+// regalloc
+s32 Sched_Schedule(SchedContext* sc, OSScTask** sp, OSScTask** dp, s32 state) {
+    s32 ret = state;
+    OSScTask* gfxTask = sc->gfxListHead;
+    OSScTask* audioTask = sc->audioListHead;
 
-typedef struct {
-    /* 0x00 */ char unk_00[0x04];
-    /* 0x00 */ u32 unk_04;
-    /* 0x00 */ u32 unk_08;
-    /* 0x0C */ UNK_TYPE unk_0C;
-    /* 0x10 */ char unk_10[0x40];
-    /* 0x50 */ OSMesgQueue* msgQ;
-    /* 0x54 */ OSMesg msg;
-} struct_800C8C40;
+    if (sc->doAudio && ret & OS_SC_SP) {
+        *sp = audioTask;
+        ret &= ~OS_SC_SP;
+        sc->doAudio = 0;
+        sc->audioListHead = sc->audioListHead->next;
+        if (sc->audioListHead == NULL) {
+            sc->audioListTail = NULL;
+        }
+    } else {
+        if (gfxTask != NULL) {
+            if (gfxTask->state & OS_SC_YIELDED || !(sc->gfxListHead->flags & OS_SC_NEEDS_RDP)) {
+                if (ret & OS_SC_SP) {
+                    *sp = gfxTask;
+                    ret &= ~OS_SC_SP;
+                    sc->gfxListHead = sc->gfxListHead->next;
+                    if (sc->gfxListHead == NULL) {
+                        sc->gfxListTail = NULL;
+                    }
+                }
+            } else {
+                if (ret == (OS_SC_SP | OS_SC_DP)) {
+                    if (sc->gfxListHead->framebuffer == NULL || func_800C89D4(sc, gfxTask) != NULL) {
+                        *sp = *dp = gfxTask;
+                        ret &= ~(OS_SC_SP | OS_SC_DP);
+                        sc->gfxListHead = sc->gfxListHead->next;
+                        if (sc->gfxListHead == NULL) {
+                            sc->gfxListTail = NULL;
+                        }
+                    }
+                }
+            }
+        }
+    }
+    return ret;
+}
+#else
+#pragma GLOBAL_ASM("asm/non_matchings/code/sched/Sched_Schedule.s")
+#endif
 
-void func_800C8BC4(SchedContext* sc, struct_800C8C40* arg1) {
-    if (sc->pendingSwapBuf1 == 0) {
-        sc->pendingSwapBuf1 = arg1->unk_0C;
+void func_800C8BC4(SchedContext* sc, OSScTask* task) {
+    if (sc->pendingSwapBuf1 == NULL) {
+        sc->pendingSwapBuf1 = task->framebuffer;
 
         LogUtils_CheckValidPointer("sc->pending_swapbuffer1", sc->pendingSwapBuf1, "../sched.c", 618);
 
-        if ((sc->unk_240 == NULL) || (sc->unk_240->unk_12 < 1)) {
-            func_800C84E4(sc, arg1->unk_0C);
+        if ((sc->curBuf == NULL) || (sc->curBuf->updateRate2 < 1)) {
+            func_800C84E4(sc, task->framebuffer);
         }
     }
 }
 
-u32 func_800C8C40(SchedContext* sc, struct_800C8C40* arg1) {
-    if (!(arg1->unk_04 & 3)) {
-        if (arg1->msgQ != NULL) {
-            osSendMesg(arg1->msgQ, arg1->msg, OS_MESG_BLOCK);
+u32 Sched_IsComplete(SchedContext* sc, OSScTask* task) {
+    if (!(task->state & (OS_SC_DP | OS_SC_SP))) {
+        if (task->msgQ != NULL) {
+            osSendMesg(task->msgQ, task->msg, OS_MESG_BLOCK);
         }
 
-        if (arg1->unk_08 & 0x40) {
-            func_800C8BC4(sc, arg1);
+        if (task->flags & OS_SC_SWAPBUFFER) {
+            func_800C8BC4(sc, task);
         }
 
         return 1;
@@ -81,34 +253,259 @@ u32 func_800C8C40(SchedContext* sc, struct_800C8C40* arg1) {
     return 0;
 }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8CB8.s")
+void Sched_RunTask(SchedContext* sc, OSScTask* spTask, OSScTask* dpTask) {
+
+    if (sc->curRSPTask != NULL) {
+        __assert("sc->curRSPTask == NULL", "../sched.c", 663);
+    }
+    if (spTask != NULL) {
+        if (spTask->list.t.type == 0) {
+            if (spTask->flags & OS_SC_NEEDS_RSP) {
+                spTask->state &= ~OS_SC_SP;
+                sc->curRSPTask = NULL;
+            }
+            if (spTask->flags & OS_SC_NEEDS_RDP) {
+                spTask->state &= ~OS_SC_DP;
+                sc->curRDPTask = NULL;
+            }
+            Sched_IsComplete(sc, spTask);
+            return;
+        }
+        spTask->state &= ~(OS_SC_YIELD | OS_SC_YIELDED);
+        osWritebackDCacheAll();
+        osSpTaskLoad(&spTask->list);
+
+        if (spTask->list.t.type == M_AUDTASK) {
+            sRSPAudioStartTime = osGetTime();
+        } else if (spTask->list.t.type == M_GFXTASK) {
+            sRSPGFXStartTime = osGetTime();
+        } else {
+            sRSPOtherStartTime = osGetTime();
+        }
+
+        osSpTaskStartGo(&spTask->list);
+        if (sLogScheduler) {
+            osSyncPrintf(
+                "%08d:osSpTaskStartGo(%08x) %s\n", (u32)OS_CYCLES_TO_USEC(osGetTime()), &spTask->list,
+                (spTask->list.t.type == M_AUDTASK ? "AUDIO" : (spTask->list.t.type == M_GFXTASK ? "GRAPH" : "OTHER")));
+        }
+        sc->curRSPTask = spTask;
+        if (spTask == dpTask && sc->curRDPTask == NULL) {
+            sc->curRDPTask = dpTask;
+            sRDPStartTime = sRSPGFXStartTime;
+        }
+    }
+}
+
+void Sched_HandleEntry(SchedContext* sc) {
+    OSScTask* nextRSP;
+    OSScTask* nextRDP;
+    u32 state;
+    OSMesg msg;
+
+    nextRSP = NULL;
+    nextRDP = NULL;
+    msg = NULL;
+    while (osRecvMesg(&sc->cmdQ, &msg, OS_MESG_NOBLOCK) != -1) {
+        Sched_QueueTask(sc, msg);
+    }
+
+    if (sc->doAudio != 0 && sc->curRSPTask != NULL) {
+        if (sLogScheduler) {
+            osSyncPrintf("[YIELD B]");
+        }
+        Sched_Yield(sc);
+        return;
+    }
+    state = ((sc->curRSPTask == 0) * 2) | (sc->curRDPTask == 0);
+    if (Sched_Schedule(sc, &nextRSP, &nextRDP, state) != state) {
+        Sched_RunTask(sc, nextRSP, nextRDP);
+    }
+    if (sLogScheduler) {
+        osSyncPrintf("EN sc:%08x sp:%08x dp:%08x state:%x\n", sc, nextRSP, nextRDP, state);
+    }
+}
+
+void Sched_HandleRetrace(SchedContext* sc) {
+    if (sLogScheduler) {
+        osSyncPrintf("%08d:scHandleRetrace %08x\n", (u32)OS_CYCLES_TO_USEC(osGetTime()), osViGetCurrentFramebuffer());
+    }
+    ViConfig_UpdateBlack();
+    sc->retraceCnt++;
+    if (osViGetCurrentFramebuffer() == (u32*)(sc->pendingSwapBuf1 != NULL ? sc->pendingSwapBuf1->swapBuffer : NULL)) {
+        if (sc->curBuf != NULL) {
+            sc->curBuf->unk_10 = 0;
+        }
+
+        if (sc->pendingSwapBuf1 != NULL) {
+            sc->pendingSwapBuf1->unk_10 = 0;
+        }
+        sc->curBuf = sc->pendingSwapBuf1;
+        sc->pendingSwapBuf1 = sc->pendingSwapBuf2;
+        sc->pendingSwapBuf2 = NULL;
+    }
+    if (sc->curBuf != NULL) {
+        if (sc->curBuf->updateRate2 > 0) {
+            sc->curBuf->updateRate2--;
+        }
+
+        if ((sc->curBuf->updateRate2 <= 0) && (sc->pendingSwapBuf1 != NULL)) {
+            func_800C84E4(sc, sc->pendingSwapBuf1);
+        }
+    }
+    if (sLogScheduler) {
+        osSyncPrintf("%08x %08x %08x %d\n", osViGetCurrentFramebuffer(), osViGetNextFramebuffer(),
+                     sc->pendingSwapBuf1 != NULL ? sc->pendingSwapBuf1->swapBuffer : NULL,
+                     sc->curBuf != NULL ? sc->curBuf->updateRate2 : 0);
+    }
+    Sched_HandleEntry(sc);
+}
+
+void Sched_HandleRSPDone(SchedContext* sc) {
+    OSScTask* curRSPTask;
+    OSScTask* nextRSP;
+    OSScTask* nextRDP;
+    s32 state;
+
+    nextRSP = NULL;
+    nextRDP = NULL;
+    if (sc->curRSPTask == NULL) {
+        __assert("sc->curRSPTask", "../sched.c", 819);
+    }
+
+    if (sc->curRSPTask->list.t.type == M_AUDTASK) {
+        gRSPAudioTotalTime += osGetTime() - sRSPAudioStartTime;
+    } else if (sc->curRSPTask->list.t.type == M_GFXTASK) {
+        gRSPGFXTotalTime += osGetTime() - sRSPGFXStartTime;
+    } else {
+        gRSPOtherTotalTime += osGetTime() - sRSPOtherStartTime;
+    }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C8EDC.s")
+    curRSPTask = sc->curRSPTask;
+    sc->curRSPTask = NULL;
+    if (sLogScheduler) {
+        osSyncPrintf("RSP DONE %d %d", curRSPTask->state & 0x10, osSpTaskYielded(&curRSPTask->list));
+    }
+    if (curRSPTask->state & OS_SC_YIELD && osSpTaskYielded(&curRSPTask->list)) {
+        if (sLogScheduler) {
+            osSyncPrintf("[YIELDED]\n");
+        }
+        curRSPTask->state |= OS_SC_YIELDED;
+        curRSPTask->next = sc->gfxListHead;
+        sc->gfxListHead = curRSPTask;
+        if (sc->gfxListTail == NULL) {
+            sc->gfxListTail = curRSPTask;
+        }
+    } else {
+        if (sLogScheduler) {
+            osSyncPrintf("[NOT YIELDED]\n");
+        }
+        curRSPTask->state &= ~OS_SC_SP;
+        Sched_IsComplete(sc, curRSPTask);
+    }
+    state = ((sc->curRSPTask == NULL) << 1) | (sc->curRDPTask == NULL);
+    if (Sched_Schedule(sc, &nextRSP, &nextRDP, state) != state) {
+        Sched_RunTask(sc, nextRSP, nextRDP);
+    }
+    if (sLogScheduler) {
+        osSyncPrintf("SP sc:%08x sp:%08x dp:%08x state:%x\n", sc, nextRSP, nextRDP, state);
+    }
+}
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C9018.s")
+void Sched_HandleRDPDone(SchedContext* sc) {
+    OSScTask* curTask;
+    OSScTask* nextRSP;
+    OSScTask* nextRDP;
+    s32 state;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C91BC.s")
+    nextRSP = NULL;
+    nextRDP = NULL;
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C94B4.s")
+    gRDPTotalTime = osGetTime() - sRDPStartTime;
+    if (sc->curRDPTask == NULL) {
+        __assert("sc->curRDPTask", "../sched.c", 878);
+    }
+    if (sc->curRDPTask->list.t.type != M_GFXTASK) {
+        __assert("sc->curRDPTask->list.t.type == M_GFXTASK", "../sched.c", 879);
+    }
+    curTask = sc->curRDPTask;
+    sc->curRDPTask = NULL;
+    curTask->state &= ~OS_SC_DP;
+    Sched_IsComplete(sc, curTask);
+    state = ((sc->curRSPTask == NULL) << 1) | (sc->curRDPTask == NULL);
+    if (Sched_Schedule(sc, &nextRSP, &nextRDP, state) != state) {
+        Sched_RunTask(sc, nextRSP, nextRDP);
+    }
+    if (sLogScheduler) {
+        osSyncPrintf("DP sc:%08x sp:%08x dp:%08x state:%x\n", sc, nextRSP, nextRDP, state);
+    }
+}
 
-void func_800C95F8(OSMesgQueue* mq) {
-    if (D_8012D290 != 0) {
+void Sched_SendEntryMsg(OSMesgQueue* mq) {
+    if (sLogScheduler) {
         osSyncPrintf("osScKickEntryMsg\n");
     }
 
-    osSendMesg(mq, 670, OS_MESG_BLOCK);
+    osSendMesg(mq, ENTRY_MSG, OS_MESG_BLOCK);
 }
 
-#pragma GLOBAL_ASM("asm/non_matchings/code/sched/func_800C9644.s")
+void Sched_ThreadEntry(void* arg) {
+    void* msg;
+    SchedContext* sc = (SchedContext*)arg;
+
+    msg = NULL;
+    while (1) {
+        if (sLogScheduler) {
+            // %08d: standby
+            osSyncPrintf("%08d:待機中\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
+        }
+
+        osRecvMesg(&sc->interruptQ, &msg, OS_MESG_BLOCK);
+
+        switch ((s32)msg) {
+            case ENTRY_MSG:
+                if (sLogScheduler) {
+                    osSyncPrintf("%08d:ENTRY_MSG\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
+                }
+                Sched_HandleEntry(sc);
+                continue;
+            case RSP_DONE_MSG:
+                if (sLogScheduler) {
+                    osSyncPrintf("%08d:RSP_DONE_MSG\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
+                }
+                Sched_HandleRSPDone(sc);
+                continue;
+            case RDP_DONE_MSG:
+                if (sLogScheduler) {
+                    osSyncPrintf("%08d:RDP_DONE_MSG\n", (u32)OS_CYCLES_TO_USEC(osGetTime()));
+                }
+                Sched_HandleRDPDone(sc);
+                continue;
+            default:
+                break;
+        }
+        switch (((OSScMsg*)msg)->type) {
+            case 1:
+                Sched_HandleRetrace(sc);
+                continue;
+            case 4:
+                Sched_HandleReset(sc);
+                continue;
+            case 3:
+                Sched_HandleStart(sc);
+                continue;
+        }
+    }
+}
 
-void func_800C9874(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, UNK_TYPE arg5) {
+void Sched_Init(SchedContext* sc, void* stack, OSPri priority, UNK_TYPE arg3, UNK_TYPE arg4, IrqMgr* irqMgr) {
     bzero(sc, sizeof(SchedContext));
     sc->unk_24C = 1;
     osCreateMesgQueue(&sc->interruptQ, sc->intBuf, 8);
     osCreateMesgQueue(&sc->cmdQ, sc->cmdMsgBuf, 8);
-    osSetEventMesg(4, &sc->interruptQ, 667);
-    osSetEventMesg(9, &sc->interruptQ, 668);
-    IrqMgr_AddClient(arg5, &sc->unk_250, sc);
-    osCreateThread(&sc->thread, 5, func_800C9644, sc, stack, priority);
+    osSetEventMesg(OS_EVENT_SP, &sc->interruptQ, RSP_DONE_MSG);
+    osSetEventMesg(OS_EVENT_DP, &sc->interruptQ, RDP_DONE_MSG);
+    IrqMgr_AddClient(irqMgr, &sc->irqClient, &sc->interruptQ);
+    osCreateThread(&sc->thread, 5, Sched_ThreadEntry, sc, stack, priority);
     osStartThread(&sc->thread);
 }
diff --git a/src/code/speed_meter.c b/src/code/speed_meter.c
index 35790bbf1..0e04fa954 100644
--- a/src/code/speed_meter.c
+++ b/src/code/speed_meter.c
@@ -2,6 +2,21 @@
 #include <global.h>
 #include <vt.h>
 
+volatile OSTime D_8016A520;
+volatile OSTime D_8016A528;
+volatile OSTime D_8016A530;
+volatile OSTime D_8016A538;
+volatile OSTime D_8016A540;
+volatile OSTime D_8016A548;
+volatile OSTime D_8016A550;
+volatile OSTime D_8016A558;
+volatile OSTime gRSPAudioTotalTime;
+volatile OSTime gRSPGFXTotalTime;
+volatile OSTime gRSPOtherTotalTime;
+volatile OSTime D_8016A578;
+volatile OSTime gRDPTotalTime;
+SpeedMeterTimeEntry* gSpeedMeterTimeEntryPtr;
+
 SpeedMeterTimeEntry sSpeedMeterTimeEntryArray[] = {
     { &D_8016A520, 0, 0, GPACK_RGBA5551(0xFF, 0x00, 0x00, 1) },
     { &D_8016A528, 0, 2, GPACK_RGBA5551(0xFF, 0xFF, 0x00, 1) },
diff --git a/src/code/sys_matrix.c b/src/code/sys_matrix.c
index 487e1a841..46a2944c8 100644
--- a/src/code/sys_matrix.c
+++ b/src/code/sys_matrix.c
@@ -21,7 +21,7 @@ MtxF* sMatrixStack;   // "Matrix_stack"
 MtxF* sCurrentMatrix; // "Matrix_now"
 
 void Matrix_Init(GameState* gameState) {
-    sCurrentMatrix = GameState_AllocEnd(gameState, 20 * sizeof(MtxF), "../sys_matrix.c", 153);
+    sCurrentMatrix = GameState_Alloc(gameState, 20 * sizeof(MtxF), "../sys_matrix.c", 153);
     sMatrixStack = sCurrentMatrix;
 }
 
diff --git a/src/code/z_construct.c b/src/code/z_construct.c
index 8d8d73faf..e1aefde9b 100644
--- a/src/code/z_construct.c
+++ b/src/code/z_construct.c
@@ -40,7 +40,7 @@ void func_801109B0(GlobalContext* globalCtx) {
     // Translates to: "Permanent PARAMETER Segment = %x"
     osSyncPrintf("常駐ＰＡＲＡＭＥＴＥＲセグメント=%x\n", parameterSize);
 
-    interfaceCtx->parameterSegment = GameState_AllocEnd(&globalCtx->state, parameterSize, "../z_construct.c", 159);
+    interfaceCtx->parameterSegment = GameState_Alloc(&globalCtx->state, parameterSize, "../z_construct.c", 159);
 
     osSyncPrintf("parameter->parameterSegment=%x", interfaceCtx->parameterSegment);
 
@@ -50,7 +50,7 @@ void func_801109B0(GlobalContext* globalCtx) {
 
     DmaMgr_SendRequest1(interfaceCtx->parameterSegment, parameterStart, parameterSize, "../z_construct.c", 162);
 
-    interfaceCtx->do_actionSegment = GameState_AllocEnd(&globalCtx->state, 0x480, "../z_construct.c", 166);
+    interfaceCtx->do_actionSegment = GameState_Alloc(&globalCtx->state, 0x480, "../z_construct.c", 166);
 
     // Translates to: "DO Action Texture Initialization"
     osSyncPrintf("ＤＯアクション テクスチャ初期=%x\n", 0x480);
@@ -84,7 +84,7 @@ void func_801109B0(GlobalContext* globalCtx) {
     DmaMgr_SendRequest1((void*)((u32)interfaceCtx->do_actionSegment + 0x300), do_actionStart + do_actionOffset, 0x180,
                         "../z_construct.c", 178);
 
-    interfaceCtx->icon_itemSegment = GameState_AllocEnd(&globalCtx->state, 0x4000, "../z_construct.c", 190);
+    interfaceCtx->icon_itemSegment = GameState_Alloc(&globalCtx->state, 0x4000, "../z_construct.c", 190);
 
     // Translates to: "Icon Item Texture Initialization = %x"
     osSyncPrintf("アイコンアイテム テクスチャ初期=%x\n", 0x4000);
@@ -201,7 +201,7 @@ void func_80110F68(GlobalContext* globalCtx) {
 
     View_Init(&msgCtx->view, globalCtx->state.gfxCtx);
 
-    msgCtx->textboxSegment = GameState_AllocEnd(&globalCtx->state, 0x2200, "../z_construct.c", 349);
+    msgCtx->textboxSegment = GameState_Alloc(&globalCtx->state, 0x2200, "../z_construct.c", 349);
 
     osSyncPrintf("message->fukidashiSegment=%x\n", msgCtx->textboxSegment);
 
diff --git a/src/code/z_effect_soft_sprite.c b/src/code/z_effect_soft_sprite.c
index bc9afa476..8c99bb380 100644
--- a/src/code/z_effect_soft_sprite.c
+++ b/src/code/z_effect_soft_sprite.c
@@ -16,7 +16,7 @@ void EffectSs_InitInfo(GlobalContext* globalCtx, s32 tableSize) {
     }
 
     sEffectSsInfo.table =
-        GameState_AllocEnd(&globalCtx->state, tableSize * sizeof(EffectSs), "../z_effect_soft_sprite.c", 289);
+        GameState_Alloc(&globalCtx->state, tableSize * sizeof(EffectSs), "../z_effect_soft_sprite.c", 289);
     if (sEffectSsInfo.table == NULL) {
         __assert("EffectSS2Info.data_table != NULL", "../z_effect_soft_sprite.c", 290);
     }
diff --git a/src/code/z_jpeg.c b/src/code/z_jpeg.c
index 070cdadf7..609d1412f 100644
--- a/src/code/z_jpeg.c
+++ b/src/code/z_jpeg.c
@@ -60,7 +60,7 @@ u32 Jpeg_SendTask(JpegContext* ctx) {
     ctx->scTask.list.t = sJpegTask;
 
     osSendMesg(&gSchedContext.cmdQ, (OSMesg)&ctx->scTask, OS_MESG_BLOCK);
-    func_800C95F8(&gSchedContext); // osScKickEntryMsg
+    Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg
     osRecvMesg(&ctx->mq, NULL, OS_MESG_BLOCK);
 }
 
diff --git a/src/code/z_kaleido_manager.c b/src/code/z_kaleido_manager.c
index 4095e6a6a..5fb9316e3 100644
--- a/src/code/z_kaleido_manager.c
+++ b/src/code/z_kaleido_manager.c
@@ -53,7 +53,7 @@ void KaleidoManager_Init(GlobalContext* globalCtx) {
     osSyncPrintf(VT_FGCOL(GREEN));
     osSyncPrintf("KaleidoArea の最大サイズは %d バイトを確保します\n", largestOvl);
     osSyncPrintf(VT_RST);
-    sKaleidoAreaPtr = GameState_AllocEnd(&globalCtx->state, largestOvl, "../z_kaleido_manager.c", 150);
+    sKaleidoAreaPtr = GameState_Alloc(&globalCtx->state, largestOvl, "../z_kaleido_manager.c", 150);
     LogUtils_CheckNullPointer("KaleidoArea_allocp", sKaleidoAreaPtr, "../z_kaleido_manager.c", 151);
     osSyncPrintf(VT_FGCOL(GREEN));
     osSyncPrintf("KaleidoArea %08x - %08x\n", sKaleidoAreaPtr, (u32)sKaleidoAreaPtr + largestOvl);
diff --git a/src/code/z_map_exp.c b/src/code/z_map_exp.c
index aea0719ba..690553acf 100644
--- a/src/code/z_map_exp.c
+++ b/src/code/z_map_exp.c
@@ -232,7 +232,7 @@ void Map_Init(GlobalContext* globalCtx) {
     interfaceCtx->unk_258 = -1;
     interfaceCtx->unk_25A = -1;
 
-    interfaceCtx->mapSegment = GameState_AllocEnd(&globalCtx->state, 0x1000, "../z_map_exp.c", 457);
+    interfaceCtx->mapSegment = GameState_Alloc(&globalCtx->state, 0x1000, "../z_map_exp.c", 457);
     // Translates to "ＭＡＰ TEXTURE INITIALIZATION scene_data_ID=%d mapSegment=%x"
     osSyncPrintf("\n\n\nＭＡＰ テクスチャ初期化   scene_data_ID=%d\nmapSegment=%x\n\n", globalCtx->sceneNum,
                  interfaceCtx->mapSegment, globalCtx);
diff --git a/src/code/z_map_mark.c b/src/code/z_map_mark.c
index deeeefaf7..510731fc6 100644
--- a/src/code/z_map_mark.c
+++ b/src/code/z_map_mark.c
@@ -57,7 +57,7 @@ void MapMark_Init(GlobalContext* globalCtx) {
     MapMarkDataOverlay* overlay = &sMapMarkDataOvl;
     u32 overlaySize = (u32)overlay->vramEnd - (u32)overlay->vramStart;
 
-    overlay->loadedRamAddr = GameState_AllocEnd(&globalCtx->state, overlaySize, "../z_map_mark.c", 235);
+    overlay->loadedRamAddr = GameState_Alloc(&globalCtx->state, overlaySize, "../z_map_mark.c", 235);
     LogUtils_CheckNullPointer("dlftbl->allocp", overlay->loadedRamAddr, "../z_map_mark.c", 236);
 
     Overlay_Load(overlay->vromStart, overlay->vromEnd, overlay->vramStart, overlay->vramEnd, overlay->loadedRamAddr);
diff --git a/src/code/z_msgevent.c b/src/code/z_msgevent.c
index c0fb5c897..3a0f3f417 100644
--- a/src/code/z_msgevent.c
+++ b/src/code/z_msgevent.c
@@ -16,6 +16,6 @@ void MsgEvent_SendNullTask() {
     task.list.t.type = M_NULTASK;
     osCreateMesgQueue(task.msgQ, &msg, 1);
     osSendMesg(&gSchedContext.cmdQ, &task, OS_MESG_BLOCK);
-    func_800C95F8(&gSchedContext); // osScKickEntryMsg
+    Sched_SendEntryMsg(&gSchedContext); // osScKickEntryMsg
     osRecvMesg(&queue, NULL, OS_MESG_BLOCK);
 }
diff --git a/src/code/z_play.c b/src/code/z_play.c
index 2f1411a92..fcb0ae136 100644
--- a/src/code/z_play.c
+++ b/src/code/z_play.c
@@ -371,7 +371,7 @@ void Gameplay_Init(GlobalContext* globalCtx) {
 
     osSyncPrintf("ZELDA ALLOC SIZE=%x\n", THA_GetSize(&globalCtx->state.tha));
     zAllocSize = THA_GetSize(&globalCtx->state.tha);
-    zAlloc = GameState_AllocEnd(&globalCtx->state, zAllocSize, "../z_play.c", 2918);
+    zAlloc = GameState_Alloc(&globalCtx->state, zAllocSize, "../z_play.c", 2918);
     zAllocAligned = (void*)(((u32)zAlloc + 8) & ~0xF);
     ZeldaArena_Init(zAllocAligned, zAllocSize - (u32)zAllocAligned + (u32)zAlloc);
     osSyncPrintf("ゼルダヒープ %08x-%08x\n", zAllocAligned,
@@ -1457,7 +1457,7 @@ void* Gameplay_LoadFile(GlobalContext* globalCtx, RomFile* file) {
     void* allocp;
 
     size = file->vromEnd - file->vromStart;
-    allocp = GameState_AllocEnd(&globalCtx->state, size, "../z_play.c", 4692);
+    allocp = GameState_Alloc(&globalCtx->state, size, "../z_play.c", 4692);
     DmaMgr_SendRequest1(allocp, file->vromStart, size, "../z_play.c", 4694);
 
     return allocp;
diff --git a/src/code/z_room.c b/src/code/z_room.c
index 90ca8ce64..f77216da6 100644
--- a/src/code/z_room.c
+++ b/src/code/z_room.c
@@ -566,7 +566,7 @@ u32 func_80096FE8(GlobalContext* globalCtx, RoomContext* roomCtx) {
     osSyncPrintf(VT_FGCOL(YELLOW));
     // Translates to: "ROOM BUFFER SIZE=%08x(%5.1fK)"
     osSyncPrintf("部屋バッファサイズ=%08x(%5.1fK)\n", maxRoomSize, (f64)(maxRoomSize * 0.0009765625f));
-    roomCtx->bufPtrs[0] = GameState_AllocEnd(&globalCtx->state, maxRoomSize, "../z_room.c", 946);
+    roomCtx->bufPtrs[0] = GameState_Alloc(&globalCtx->state, maxRoomSize, "../z_room.c", 946);
     // Translates to: "ROOM BUFFER INITIAL POINTER=%08x"
     osSyncPrintf("部屋バッファ開始ポインタ=%08x\n", roomCtx->bufPtrs[0]);
     roomCtx->bufPtrs[1] = (void*)((s32)roomCtx->bufPtrs[0] + maxRoomSize);
diff --git a/src/code/z_sample.c b/src/code/z_sample.c
index 74e7639f2..4997f7bbe 100644
--- a/src/code/z_sample.c
+++ b/src/code/z_sample.c
@@ -82,7 +82,7 @@ void Sample_SetupView(SampleContext* this) {
 void Sample_LoadTitleStatic(SampleContext* this) {
     u32 size = _title_staticSegmentRomEnd - _title_staticSegmentRomStart;
 
-    this->staticSegment = GameState_AllocEnd(&this->state, size, "../z_sample.c", 163);
+    this->staticSegment = GameState_Alloc(&this->state, size, "../z_sample.c", 163);
     DmaMgr_SendRequest1(this->staticSegment, _title_staticSegmentRomStart, size, "../z_sample.c", 164);
 }
 
diff --git a/src/code/z_scene.c b/src/code/z_scene.c
index 3c2825ca3..23ad42dbd 100644
--- a/src/code/z_scene.c
+++ b/src/code/z_scene.c
@@ -72,7 +72,7 @@ void Object_InitBank(GlobalContext* globalCtx, ObjectContext* objectCtx) {
     osSyncPrintf(VT_RST);
 
     objectCtx->spaceStart = objectCtx->status[0].segment =
-        GameState_AllocEnd(&globalCtx->state, spaceSize, "../z_scene.c", 219);
+        GameState_Alloc(&globalCtx->state, spaceSize, "../z_scene.c", 219);
     objectCtx->spaceEnd = (void*)((s32)objectCtx->spaceStart + spaceSize);
 
     objectCtx->mainKeepIndex = Object_Spawn(objectCtx, OBJECT_GAMEPLAY_KEEP);