void handleTimerInterrupt(int segment, int stackPointer){
struct PCB *pcb ;
struct PCB *head;
setKernelDataSegment();
pcb = getFreePCB();
if(pcb->state != DEFUNCT){
}
pcb->stackPointer = stackPointer;
pcb->state = READY;
addToReady(pcb);
head = removeFromReady();
restoreDataSegment();
setKernelDataSegment();
if(head == NULL){
head = idleProc;
}
head->state = RUNNING;
restoreDataSegment();
setKernelDataSegment();
running = head;
restoreDataSegment();
//printString("tic");
returnFromTimer(head->segment, head->stackPointer);
}
void handleTimerInterrupt(int segment, int sp){
int q;
int nextProcess;
if(segment == findProcessTableSegment(currentProcess)){
processTable[currentProcess].stackPointer = sp;
}
nextProcess = currentProcess + 1;
for(q=0; q<NUMBEROFPROCESSENTRIES; q++){
while(nextProcess >= NUMBEROFPROCESSENTRIES){
nextProcess -= NUMBEROFPROCESSENTRIES;
}
if(processTable[nextProcess].active == 1 && processTable[nextProcess].waitingOn == NOONE){
break;
}
nextProcess++;
}
sp = processTable[nextProcess].stackPointer;
segment = findProcessTableSegment(nextProcess);
currentProcess = nextProcess;
returnFromTimer(segment, sp);
}
void handleTimerInterrupt(int segment, int stackPointer){
struct PCB *pcb;
setKernelDataSegment();
(*running).stackPointer = stackPointer;
(*running).segment = segment;
if((*running).state != DEFUNCT && (*running).name != "idle\0"){
(*running).state = READY;
addToReady(running);
}
pcb = removeFromReady();
if(pcb == NULL){
running = &idleProc;
}else{
(*pcb).state = RUNNING;
running = pcb;
}
returnFromTimer((*running).segment,(*running).stackPointer);
restoreDataSegment();
}
void handleTimerInterrupt(int segment, int sp) {
int curProcUser, curProcSegUser, curProcSpUser, count, wait, parentWait;
setKernelDataSegment();
curProcSegUser = segment;
curProcSpUser = sp;
curProcUser = div(curProcSegUser, 0x1000) - 2;
if (curProcUser >= 0) {
procTable[curProcUser].sp = sp;
}
for (count = 0; count <= PROC_ENTRY_NUM; count++) {
curProcUser = (curProcUser + 1) % PROC_ENTRY_NUM;
/* TODO: Not very efficient, wait to be changed */
wait = procTable[curProcUser].waiting;
if (wait != -1) { /* Current process is waiting for `wait` */
parentWait = procTable[wait].waiting;
if (!procTable[wait].active && parentWait == -1) {
procTable[curProcUser].waiting = -1;
procTable[curProcUser].active = 1;
}
}
if (procTable[curProcUser].active == 1) {
currentProcess = curProcUser;
curProcSegUser = currentProcess * 0x1000 + 0x2000;
curProcSpUser = procTable[currentProcess].sp;
break;
}
}
restoreDataSegment();
returnFromTimer(curProcSegUser, curProcSpUser);
}
void handleTimerInterrupt(int segment, int sp)
{
int i,process,count=1;
setKernelDataSegment();
if(segment==0x1000)
{ printString("segment=1000");
currentProcess=-1;
}
else
{
p[currentProcess].sp=sp;
}
process=currentProcess+1;
if (segment == 0x1000)
{
putInMemory(0xB000, 0x8162, 'K');
putInMemory(0xB000, 0x8163, 0x7);
}
else if (segment == 0x2000)
{
putInMemory(0xB000, 0x8164, '0');
putInMemory(0xB000, 0x8165, 0x7);
}
else if (segment == 0x3000)
{
putInMemory(0xB000, 0x8166, '1');
putInMemory(0xB000, 0x8167, 0x7);
}
else
{
putInMemory(0xB000, 0x8160, 'X');
putInMemory(0xB000, 0x8161, 0x7);
}
while(process<8)
{
if(p[process].active==1)
{
printString("process active");
currentProcess=process;
segment=process+2;
segment=segment*0x1000;
if( p[process].sp == 0xff00 )
printString("segment=0x2000");
restoreDataSegment();
returnFromTimer(segment,p[process].sp);
}
if(count==8)
{
printString("breaking");
break;
}
if(process==7)
{
printString("process==7");
process=0;
}
else
{
process++;
}
count++;
}
// printString("Tic");
restoreDataSegment();
returnFromTimer(segment,sp);
}
