void CPU_scheduler(CPU_p cpu, Interrupt_type interrupt_type, int PC) {
while (!Queue_isEmpty(cpu->newProcessesQueue)) {
PCB_p temp_pcb = Queue_dequeue(cpu->newProcessesQueue);
PCB_set_state(temp_pcb, ready);
//PCB_set_pc(temp_pcb, PC);
Queue_enqueue(cpu->readyQueue, temp_pcb);
fprintf(file, "Process ID: %u Enqueued\n", temp_pcb->pid);
fprintf(file, "%s", PCB_toString(temp_pcb));
}
fprintf(file, "\n");
switch (interrupt_type) {
case timer:
// 1. Put process back into the readyQueue
Queue_enqueue(cpu->readyQueue, cpu->currentProcess);
// 2. Change its state from interrupted to ready
PCB_set_state(cpu->currentProcess, ready);
// 3. Make call to dispatcher
CPU_dispatcher(cpu, timer);
// 4. Returned from dispatcher, do any housekeeping
// Nothing here to do at the moment!
// 5. Returns to pseudo-ISR
return;
break;
default:
CPU_dispatcher(cpu, normal);
break;
}
return;
}
bool DLL_EXPORT check(Queue_t queue){
if(Queue_getSize(queue) < 3) return false;
while(Queue_getSize(queue) > 3){
Queue_dequeue(queue);
}
while(!Queue_isEmpty(queue)){
if(Queue_dequeue(queue) > 0) return false;
}
return true;
}
/*
* Return: 0 - succeed
*
*/
int Queue_clear(Queue *q)
{
if(q == NULL)
{
return 0;
}
#ifdef QUEUE_DEBUG
printf("[%s()]: q->header=[%d], q->tail=[%d]\n", __LINE__, q->header, q->tail);
#endif
if(Queue_isEmpty(q) == QUEUE_IS_EMPTY)
{
return 0;
}
q->header = q->tail = 0;
return 0;
}
void CPU_dispatcher(CPU_p cpu, Interrupt_type interrupt_type) {
// Save pointers to the previous and next process (needed so we can print)
PCB_p prevProcess = cpu->currentProcess;
PCB_p nextProcess = Queue_peek(cpu->readyQueue);
if (CTX_SWITCH_COUNT % 4 == 0) {
if (prevProcess != NULL)
fprintf(file, "Running process: %s", PCB_toString(prevProcess));
if (nextProcess != NULL)
fprintf(file, "Switching to: %s", PCB_toString(nextProcess));
}
// 1. Save the state of current process into its PCB (PC value)
// Per Canvas Discussions, DON'T DO THIS AGAIN HERE! It's in ISR.
// 2. Then dequeue next waiting process
if (!Queue_isEmpty(cpu->readyQueue))
cpu->currentProcess = Queue_dequeue(cpu->readyQueue);
// 3. Change its state to running
PCB_set_state(cpu->currentProcess, running);
if (interrupt_type == timer) {
// 4. Copy its PC value to sysStack, replacing the interrupted process
CPU_push_sysStack(cpu, PCB_get_PC(cpu->currentProcess));
} else if (interrupt_type == normal) {
CPU_set_pc(cpu, cpu->sysStack);
}
if (CTX_SWITCH_COUNT % 4 == 0) {
if (prevProcess != NULL)
fprintf(file, "Last Process: %s", PCB_toString(prevProcess));
if (nextProcess != NULL)
fprintf(file, "Current running Process: %s", PCB_toString(nextProcess));
fprintf(file, "Ready Queue: %s", Queue_toString(cpu->readyQueue, 0));
}
// 5. Return to the scheduler
// returns prevalent stuff to scheduler, but not for this project
return;
}
void Queue_test()
{
queue_t testQueue;
Queue_init(&testQueue, 5, sizeof(int));
assert( Queue_isEmpty(&testQueue) == true );
assert( Queue_isFull(&testQueue) == false );
int a = 34;
int b = 35;
int c = 36;
int d = 37;
int e = 38;
assert( Queue_push( &testQueue, (uint8_t*)&a ) == true);
assert( Queue_push( &testQueue, (uint8_t*)&b ) == true);
assert( Queue_push( &testQueue, (uint8_t*)&c ) == true);
assert( Queue_isEmpty(&testQueue) == false );
assert( Queue_isFull(&testQueue) == false );
assert( Queue_push( &testQueue, (uint8_t*)&d ) == true);
assert( Queue_push( &testQueue, (uint8_t*)&e ) == true);
assert( Queue_push( &testQueue, (uint8_t*)&e ) == false);
assert( Queue_isEmpty(&testQueue) == false );
assert( Queue_isFull(&testQueue) == true );
int read;
assert( Queue_pop( &testQueue, (uint8_t*)&read ) == true);
assert(read == 34);
assert( Queue_pop( &testQueue, (uint8_t*)&read ) == true);
assert(read == 35);
assert( Queue_pop( &testQueue, (uint8_t*)&read ) == true);
assert(read == 36);
assert( Queue_pop( &testQueue, (uint8_t*)&read ) == true);
assert(read == 37);
assert( Queue_pop( &testQueue, (uint8_t*)&read ) == true);
assert(read == 38);
assert( Queue_pop( &testQueue, (uint8_t*)&read ) == false);
assert(read == 38);
assert( Queue_isEmpty(&testQueue) == true );
assert( Queue_isFull(&testQueue) == false );
assert( Queue_push( &testQueue, (uint8_t*)&a ) == true);
assert( Queue_push( &testQueue, (uint8_t*)&b ) == true);
assert( Queue_push( &testQueue, (uint8_t*)&c ) == true);
Queue_clear(&testQueue);
assert( Queue_isEmpty(&testQueue) == true );
assert( Queue_isFull(&testQueue) == false );
}
