146 lines
No EOL
5.6 KiB
C
146 lines
No EOL
5.6 KiB
C
#include "configops.h"
|
|
#include "metadataops.h"
|
|
#include "StandardConstants.h"
|
|
#include "simulator.h"
|
|
|
|
/*
|
|
Name: createProcessList
|
|
Process: reads through the opcode struct to fill out the linked list of PCBs
|
|
Function Input/Parameters: none
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: head pointer to the PCBs
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: malloc, sizeof, ???
|
|
*/
|
|
ProcessControlBlockLL *createProcessList()
|
|
{
|
|
// allocate and create the ProcessControlBlockLL using malloc and size of
|
|
ProcessControlBlockLL *headBlock;
|
|
headBlock = malloc(sizeof(ProcessControlBlockLL));
|
|
// set the head pointer to NULL
|
|
headBlock->headPtr = NULL;
|
|
// return headBlock
|
|
return headBlock;
|
|
}
|
|
|
|
/*
|
|
Name: destroyProcessList
|
|
Process: deallocates memory used for the linked list struct
|
|
Function Input/Parameters: head pointer to linked list (ProcessControlBlockLL *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: NULL
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: free, destroyProcessListHelper, ???
|
|
*/
|
|
ProcessControlBlockLL *destroyProcessList(ProcessControlBlockLL *linkedListPtr)
|
|
{
|
|
// call the first destroyProcessListHelper
|
|
destroyProcessListHelper(linkedListPtr->headPtr);
|
|
// free the rest of the struct
|
|
free(linkedListPtr);
|
|
// return null
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
Name: destroyProcessListHelper
|
|
Process: recursively clears the PCB linked list struct, freeing the struct
|
|
Function Input/Parameters: head pointer to linked list (ProcessControlBlockLL *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: NULL
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: free, destroyProcessListHelper(recursively), ???
|
|
*/
|
|
ProcessControlBlock *destroyProcessListHelper(ProcessControlBlock *nodePtr)
|
|
{
|
|
// check to see if the next pointer is NOT null
|
|
if(nodePtr->nextPtr != NULL)
|
|
{
|
|
// if not null, move to the next pointer (recurse)
|
|
nodePtr->nextPtr = destroyProcessListHelper(nodePtr->nextPtr);
|
|
}
|
|
// free the 'parent' node
|
|
free(nodePtr);
|
|
// return null
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
Name: fillProcessList
|
|
Process: iterates through the metadata LL, fills out each process as needed.
|
|
(Linking is left to the calling function, returns a pointer to the filled struct)
|
|
Function Input/Parameters: metadata (OpCodeType *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: pointer to filled PCB (ProcessControlBlock *)
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: ???
|
|
*/
|
|
ProcessControlBlock *fillProcessList(OpCodeType *metadataPtr)
|
|
{
|
|
// initialize function/variables
|
|
// need a working pointer for the metadata
|
|
// need a pointer to save the location of first metadata opcode
|
|
// need a variable to count how many IO cycles are in the process
|
|
// need a variable to count how many CPU cycles are in the process
|
|
// need a variable to calculate the time left in ms for a process
|
|
// temp variables?
|
|
// loop through the process list, until you hit a sys end.
|
|
// if app start,
|
|
// set the unique ID
|
|
// set the process state to PROCESS_STATE_NEW
|
|
// set the nextOpCode as a pointer to the first place metadataPtr started
|
|
// loop while no longer have io or cpu instructions?
|
|
// count number of io cycles
|
|
// count number of cpu cycles
|
|
// set the ioCycles from variable
|
|
// set the cpuCycles from variable
|
|
// set totalCycles from adding both IO/CPU
|
|
// set the time left from (ioCycles * ioCycleRate) + (cpuCycles * procCyclesRate)
|
|
// this gets the number of ms in the process.
|
|
// return null (temp)
|
|
return (ProcessControlBlock *)NULL;
|
|
}
|
|
|
|
/*
|
|
Name: runSim
|
|
Process: primary simulation driver
|
|
Function Input/Parameters: configuration data (ConfigDataType *),
|
|
metadata (OpCodeType *)
|
|
Function Output/Parameters: none
|
|
Function Output/Returned: none
|
|
Device Input/Device: none
|
|
Device Output/Device: none
|
|
Dependencies: ???
|
|
*/
|
|
void runSim(ConfigDataType *configPtr, OpCodeType *metaDataMstrPtr)
|
|
{
|
|
// initialize function/variables
|
|
// need a FILE * for file operations
|
|
// need two working pointers, one for master loop, one for internal loop
|
|
// currentTime variable that stores the time.
|
|
// create the process list with createProcessList
|
|
// function holds master loop, loops until sys end opcode found OR PCB List != NULL
|
|
// will have a loop that goes from app start to app end for a PCB
|
|
// (checks to see if the next instruction is NOT app end), using getNextProcess?
|
|
// this will getNextOpCode
|
|
// this will checkForIO and run the IO operations, outputting to FILE * and/or monitor
|
|
// checkForIO will need the FILE * passed, will need timer access, and ???
|
|
// this will checkForCPU and run the CPU operations, outputting to FILE * and/or monitor
|
|
// checkForCPU will need the FILE * passed, will need timer access, and ???
|
|
//
|
|
// deallocate the process list with destroyProcessList
|
|
printf("runSim called here");
|
|
// void function, no return.
|
|
}
|
|
|
|
// getNextProcess/scheduler/dispatcher run here, loads/"runs" the process
|
|
// getNextOpCode, not needed for Sim02 apparently, keep in mind.
|
|
// checkForIO, I think this gets passed the current process and runs the IO ops
|
|
// checkForCPU, I think this gets passed the current process and runs the CPU ops
|
|
// checkForMemory, I think this gets passed the current process
|
|
// and runs mem ops (not needed for Sim02)
|
|
// cpuIdler (not needed for Sim02)
|