int main(int argc, char *argv[]){
/* did they specify the correct number of args */
if(!argc > 3){
printf("\nYou must provide the following arguments");
printf("\npolicy, total memory free pool size, name of file containg requests");
printf("\nExample: ./a.out best 1024 proj5_data > output.txt");
printf("\nYou only provided %d arguements.", argc);
exit(2);
}
/* break up arg vectors */
int mem = atoi(argv[2]);
/* best fit call */
if(strcmp(argv[1], "best") == 0){
bestFit(mem, argv[3]);
}
/* first fit call */
if(strcmp(argv[1], "first") == 0){
firstFit(mem, argv[3]);
}
/* buddy system call (not working)*/
if(strcmp(argv[1], "buddy") == 0){
buddySys(mem, argv[3]);
}
return 0;
}
/**
* allocate memory
**/
void*
kma_malloc(kma_size_t size)
{
// if the requested size is greater than a page, ignore it
if ((size + sizeof(void*)) > PAGESIZE)
{
return NULL;
}
// if there are no allocated page, then initate the page
if (!mainPage)
{
mainPage = get_page();
initPage(mainPage);
}
// find suitable space
void* firstFit1 = firstFit(size);
pageHeader* base = BASEADDR(firstFit1);
// increase block count
base->blockCount++;
// return block address
return firstFit1;
}
/**
* Find first fit block
**/
block* firstFit(int size)
{
int minSize = sizeof(block);
if (size < minSize)
size = minSize;
pageHeader* header = (pageHeader*)(mainPage->ptr);
block* cursor = (block*)(header->head);
while (cursor)
{
// no enough size
if (cursor->size < size)
{
cursor = cursor->next;
continue;
}
// perfect fit
else if (cursor->size == size || (cursor->size - size) < minSize)
{
deleteEntry(cursor);
return (void*)cursor;
}
// fit, add fragement to the linked list
else
{
addEntry((void*)((long int)cursor + size), (cursor->size - size));
deleteEntry(cursor);
return (void*)cursor;
}
}
// no enough space, then add a new page
kma_page_t* newPage = get_page();
initPage(newPage);
header->pageCount++;
return firstFit(size);
}
int main (void)
{
int qtdprocessos, met;
FILE* out = fopen("saida.txt","w");
int i, j, fail = 0, cnt = 0, tamProntos, tamIO, tamIO2, seg = 0, inxExec, inxIO;
Processo *aux, *procExec, *procIO, *procRetirado;
LIS_tppLista listaIO = LIS_CriarLista();
LIS_tppLista listaProntos = LIS_CriarLista();
Memory * mem = (Memory*)malloc(sizeof(Memory));
FILE* fp = fopen("entrada.txt", "r");
Processo *vp = (Processo*)malloc(100*sizeof(Processo));
qtdprocessos = lerEntrada(&fp, vp);
imprimeVetor(vp, qtdprocessos);
InicializaMemoria(mem);
procExec = NULL;
// Insere os elementos lidos numa lista de prontos
for(i = 0; i < qtdprocessos; i++)
{
LIS_InserirElementoApos(listaProntos, &vp[i]);
LIS_AvancarElementoCorrente(listaProntos, 1);
vp[i].segAtual = -1;
vp[i].naMemoria = 0;
vp[i].t_exec = 0;
vp[i].t_io = 0;
}
printf("1: First Fit \n");
printf("2: Best Fit \n");
printf("3: Worst Fit \n");
printf("4: Next Fit \n");
scanf("%d", &met);
EXEC:
IrInicioLista(listaProntos); // vai pro inicio da lista de prontos
aux = (Processo*)LIS_ObterValor(listaProntos);
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
/* * * * * * * * * * * * * * * * * * * * * * */
// executar o processo
IrInicioLista(listaProntos);
tamProntos = LIS_ObterTamanho(listaProntos);
tamIO = LIS_ObterTamanho(listaIO);
aux = (Processo*)LIS_ObterValor(listaProntos); // obtem o priemeiro elemento da lista de prontos
while(tamProntos > 0)
{
if(!aux->naMemoria) // se o processo não esta em memoria
{
LIS_AvancarElementoCorrente(listaProntos, 1);
aux = (Processo*)LIS_ObterValor(listaProntos);
continue;
}
procExec = aux;
for(i = 0; i < 10; i++) // os 10 clocks de cpu
{
ImprimirEstado(&out, listaIO, procExec, mem, tempoTotal);
clock(1); tempoTotal++;
inxExec = procExec->t_exec;
procExec->exec[inxExec]--;
tamIO = LIS_ObterTamanho(listaIO);
IrInicioLista(listaIO);
for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O
{
procIO = (Processo*)LIS_ObterValor(listaIO);
inxIO = procIO->t_io;
procIO->io[inxIO]--;
if(procIO->io[inxIO] == 0) // seu tempo de io acabou
{
LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procIO);
procIO->t_io++;
}
LIS_AvancarElementoCorrente(listaIO, 1);
}
tamIO2 = LIS_ObterTamanho(listaIO);
if(tamIO != tamIO2)
{
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
}
getNext(listaProntos);
if(procExec->exec[inxExec] == 0 || i == 9) // se o seu tempo de exec terminou entao retira da memoria
{
/* * * * * */ //imprimeMemoria(mem);
LIS_ExcluirElemento(listaProntos);
if(procExec->exec[inxExec] == 0) procExec->t_exec++; // se acabou um exec inteiro
if(procExec->exec[inxExec] == 0 && procExec->t_io < procExec->qtdio) // se o processo terminou um exec e ainda tem io para fazer
{
IrFinalLista(listaIO);
LIS_InserirElementoApos(listaIO, procExec);
}
// retira da memoria
// se o processo ainda tem exec para fazer
if(procExec->exec[inxExec] > 0)
{
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procExec);
}
seg = procExec->segAtual;
procRetirado = RetiraProcessoMem(mem, seg);
procRetirado->naMemoria = 0;
switch(met)
{
case 1:
firstFit(mem, listaProntos);
break;
case 2:
BestFit(mem, listaProntos);
break;
case 3:
WorstFit(mem, listaProntos);
break;
case 4:
NextFit(mem, listaProntos);
break;
default:
break;
}
break;
}
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
} /* final dos 10 clocks*/
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
tamProntos = LIS_ObterTamanho(listaProntos);
IrInicioLista(listaProntos);
aux = (Processo*)LIS_ObterValor(listaProntos);
}
tamIO = LIS_ObterTamanho(listaIO);
while(tamIO > 0) // entao tem IO sobrando e ngm para executar
{
IrInicioLista(listaIO);
clock(1);tempoTotal++;
for(j = 0; j < tamIO; j++) // diminui 1 de IO para todos q estao na lista de I/O
{
procIO = (Processo*)LIS_ObterValor(listaIO);
inxIO = procIO->t_io;
procIO->io[inxIO]--;
if(procIO->io[inxIO] == 0) // seu tempo de io acabou
{
LIS_ExcluirElemento(listaIO); // retira da lista de io e insere-o na lista de prontos
IrFinalLista(listaProntos);
LIS_InserirElementoApos(listaProntos, procIO);
procIO->t_io++;
}
LIS_AvancarElementoCorrente(listaIO, 1);
}
tamIO = LIS_ObterTamanho(listaIO);
tamProntos = LIS_ObterTamanho(listaProntos);
imprimeMemoria(mem);
printf("\n Lista de Prontos \n");
ImprimirLista(listaProntos);
printf("\n Lista de IO \n");
ImprimirLista(listaIO);
if(tamProntos > 0) // se alguem voltou par a lista de prontos...
goto EXEC;
}
fclose(out);
free(mem);
free(vp);
free(listaProntos);
free(listaIO);
return 0;
}
int main(int argc, char *argv[])
{
//If there are not at least 3 arguments, then quit
//ARG1: Binpack ARG2: binSize ARG3: First items
if (argc < 3) {
exit(0);
}
//Variables
int binSize;
int numItems;
int items[MAX_SIZE];
int sorted[MAX_SIZE];
int solutions[5];
//Initialize variables
for (int a = 0; a < MAX_SIZE; a++) {
items[a] = 0;
}
for (int a = 0; a < 5; a++) {
solutions[a] = -1;
}
int Flags[argc-2];
for (int a = 0; a < argc-2; a++) {
Flags[a] = 0;
}
//Read in the bin size
binSize = atoi(argv[1]);
if (binSize <= 0) {
exit(0);
}
//Flag options
char *FlagOp[5] = {"-opt", "-ff", "-bf", "-ffd", "-bfd"};
int i;
numItems = 0;
//Read in the items
for (i = 2; i < argc; i++) {
//If the arg is a flag, leave loop
if (strcmp(argv[i], FlagOp[0]) == 0 ||
strcmp(argv[i], FlagOp[1]) == 0 ||
strcmp(argv[i], FlagOp[2]) == 0 ||
strcmp(argv[i], FlagOp[3]) == 0 ||
strcmp(argv[i], FlagOp[4]) == 0) {
//If no items, then quit
if (i == 2) {
exit(0);
}
break;
}
//If an item is not a positive integer
//Or is larger than binSize
//Or if there are more than MAX_SIZE items, quit
else if (atoi(argv[i]) <= 0 ||
atoi(argv[i]) > binSize ||
numItems == MAX_SIZE) {
exit(0);
}
else {
items[i-2] = atoi(argv[i]);
numItems++;
}
}
//Read in the Flags
for (int f = 0; i < argc; f++) {
if (strcmp(argv[i], FlagOp[0]) == 0) Flags[f] = 1;
else if (strcmp(argv[i], FlagOp[1]) == 0) Flags[f] = 2;
else if (strcmp(argv[i], FlagOp[2]) == 0) Flags[f] = 3;
else if (strcmp(argv[i], FlagOp[3]) == 0) Flags[f] = 4;
else if (strcmp(argv[i], FlagOp[4]) == 0) Flags[f] = 5;
else {
exit(0);
}
i++;
}
//Make a copy of items and sort
for (int a = 0; a < MAX_SIZE; a++) {
sorted[a] = items[a];
}
sortDecreasing(sorted);
//Binpacking loop
for (int b = 0; Flags[b] != 0; b++) {
//Initialize Empty bins
int bins[numItems];
for (int a = 0; a < numItems; a++) {
bins[a] = 0;
}
//Backtracking
if (Flags[b] == 1) {
if (solutions[0] == -1) {
//Compute sum of item sizes
int sumItems = 0;
for (int p = 0; sorted[p] != 0 && p < MAX_SIZE; p++) {
sumItems += sorted[p];
}
//Heuristic B
int lowerBound = lowBound(sumItems, binSize);
//Heuristic C
int minBins = MAX_SIZE;
//Recursion
minBins = backtrack(0, binSize, numItems, bins, sorted,
lowerBound, minBins, 0, 0, 0);
solutions[0] = minBins;
}
printf("-opt %d\n", solutions[0]);
}
//First Fit
else if (Flags[b] == 2) {
if (solutions[1] == -1) {
solutions[1] = firstFit(binSize, numItems, bins, items);
}
printf("-ff %d\n", solutions[1]);
}
//Best Fit
else if (Flags[b] == 3) {
if (solutions[2] == -1) {
solutions[2] = bestFit(binSize, numItems, bins, items);
}
printf("-bf %d\n", solutions[2]);
}
//First Fit Decreasing
else if (Flags[b] == 4) {
if (solutions[3] == -1) {
solutions[3] = firstFit(binSize, numItems, bins, sorted);
}
printf("-ffd %d\n", solutions[3]);
}
//Best Fit Decreasing
else if (Flags[b] == 5) {
if (solutions[4] == -1) {
solutions[4] = bestFit(binSize, numItems, bins, sorted);
}
printf("-bfd %d\n", solutions[4]);
}
}
}
//adds a PCB to running queue using memory management
void pcbQueue::addPCBFit(char whichFit, pcb* nPCB)
{
switch(whichFit)
{
case 'F':
{
bool done = false;
done = firstFit(nPCB);
if (!done)
{
coalesce();
done = firstFit(nPCB);
}
else
{
return;
}
if (!done)
{
compact();
done = firstFit(nPCB);
}
}
break;
case 'N':
{
bool done = false;
done = nextFit(nPCB);
if (!done)
{
coalesce();
done = nextFit(nPCB);
}
if (!done)
{
compact();
done = nextFit(nPCB);
}
}
break;
case 'B':
{
bool done = false;
done = bestFit(nPCB);
if (!done)
{
coalesce();
done = bestFit(nPCB);
}
if (!done)
{
compact();
done = bestFit(nPCB);
}
}
break;
case 'W':
{
bool done = false;
done = worstFit(nPCB);
if (!done)
{
coalesce();
done = worstFit(nPCB);
}
if (!done)
{
compact();
done = worstFit(nPCB);
}
}
break;
default:
{
bool done = false;
done = firstFit(nPCB);
if (!done)
{
coalesce();
done = firstFit(nPCB);
}
if (!done)
{
compact();
done = firstFit(nPCB);
}
}
}
queueSize = heldItems.size();
}
