int ejecutaralgoritmo(int pIdProceso, int pTamanoProceso ){
switch (tipoAlgoritmo){
case 1 : return FirstFit(pIdProceso, pTamanoProceso, datos, *tamano);
case 2 : return BestFit(pIdProceso, pTamanoProceso, datos, *tamano);
case 3 : return WorstFit(pIdProceso, pTamanoProceso, datos, *tamano);
}
}
void OnlineBestFit(ListP listPtr, int* allItems, int itemsInRun){
int j, currentBin, currentItem;
ItemP item;
rewind(fpBins); // ensure every algorithm starts with the same Bin
fscanf(fpBins, "%d", ¤tBin);
addBinToList(listPtr, currentBin);
for (j = 0; j < itemsInRun; j++){
currentItem = allItems[j];
item = createItem(currentItem);
BestFit(listPtr, item);
}
}
void OfflineBestFit(ListP listPtr, int *allItems, int itemsInRun){
int j;
int currentItem, currentBin;
ItemP item;
// sort allItems
mergeSort(allItems, itemsInRun);
// create items and pack
rewind(fpBins); // ensure every algorithm starts with the same Bin
fscanf(fpBins, "%d", ¤tBin);
addBinToList(listPtr, currentBin);
for (j = 0; j < itemsInRun; j++){
currentItem = allItems[j];
item = createItem(currentItem);
BestFit(listPtr, item);
}
return;
}
void CLayerTypeGrid::OnSetup()
{
#ifdef CELL_EDIT
DWORD dwStyle = 0;
if ( m_myCUGEdit.GetSafeHwnd())
m_myCUGEdit.DestroyWindow();
dwStyle |= WS_CHILD|WS_VISIBLE;
// create the edit control with specified style
m_myCUGEdit.Create( dwStyle, CRect(0,0,0,0), this, 320001/*somerandom_ID*/ );
m_myCUGEdit.SetAutoSize(TRUE);
m_myCUGEdit.m_ctrl = this;
#endif
SetNumberCols(0);
SetNumberRows(0);
BestFit(0, GetNumberCols()-1, myUG_FIT_ALL_ROWS, UG_BESTFIT_TOPHEADINGS);
SetColWidth(-1, 0); // get rid of "row heading"
}
status_t
ScreenConfigurations::Set(int32 id, const monitor_info* info,
const BRect& frame, const display_mode& mode)
{
// Find configuration that we can overwrite
bool exactMatch;
screen_configuration* configuration = BestFit(id, info, &exactMatch);
if (configuration != NULL && configuration->has_info && !exactMatch) {
// only overwrite exact or unspecified configurations
configuration->is_current = false;
// TODO: provide a more obvious current mechanism...
configuration = NULL;
}
if (configuration == NULL) {
// we need a new configuration to store
configuration = new (std::nothrow) screen_configuration;
if (configuration == NULL)
return B_NO_MEMORY;
fConfigurations.AddItem(configuration);
}
configuration->id = id;
configuration->frame = frame;
configuration->is_current = true;
if (info != NULL) {
memcpy(&configuration->info, info, sizeof(monitor_info));
configuration->has_info = true;
} else
configuration->has_info = false;
memcpy(&configuration->mode, &mode, sizeof(display_mode));
return B_OK;
}
// Allocate a span of exactly npage pages from the list of large spans.
static MSpan*
MHeap_AllocLarge(MHeap *h, uintptr npage)
{
return BestFit(&h->large, npage, nil);
}
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()
{
char c ='4';
if(c=='1')
{
memset(memorystatus,'t',1000);
printf("Hello world!\n");
printf("Memoria Vacia\n");
puts(memorystatus);
void* ptra = (FirstFit(5));
//MiFree(ptra);
void* ptrb = (FirstFit(10));
void* ptrc = (FirstFit(15));
printf("Memoria con memoria asignada\n");
puts(memorystatus);
printf("Punteros\n");
int a = (unsigned) ptra;
int b = (unsigned) ptrb;
int c = (unsigned) ptrc;
printf("%u\n",a);
printf("%u\n",b);
printf("%u\n",c);
}
if(c=='2')
{
memset(memorystatus,'t',1000);
printf("Hello world!\n");
printf("Memoria Vacia\n");
puts(memorystatus);
void* ptra = (NextFit(5));
MiFree(ptra);
void* ptrb = (NextFit(3));
void* ptrc = (NextFit(15));
printf("Memoria con memoria asignada\n");
puts(memorystatus);
printf("Punteros\n");
int a = (unsigned) ptra;
int b = (unsigned) ptrb;
int c = (unsigned) ptrc;
printf("%u\n",a);
printf("%u\n",b);
printf("%u\n",c);
}
if(c=='3')
{
memset(memorystatus,'t',1000);
printf("Hello world!\n");
printf("Memoria Vacia\n");
puts(memorystatus);
void* ptra = (BestFit(5));
MiFree(ptra);
void* ptrb = (BestFit(10));
void* ptrc = (BestFit(15));
printf("Memoria con memoria asignada\n");
puts(memorystatus);
printf("Punteros\n");
int a = (unsigned) ptra;
int b = (unsigned) ptrb;
int c = (unsigned) ptrc;
printf("%u\n",a);
printf("%u\n",b);
printf("%u\n",c);
}
if(c=='4')
{
memset(memorystatus,'t',1000);
printf("Hello world!\n");
printf("Memoria Vacia\n");
puts(memorystatus);
void* ptra = (WorstFit(10));
//MiFree(ptra);
void* ptrb = (WorstFit(5));
// MiFree(ptrb);
void* ptrc = (WorstFit(15));
printf("Memoria con memoria asignada\n");
puts(memorystatus);
printf("Punteros\n");
int a = (unsigned) ptra;
int b = (unsigned) ptrb;
int c = (unsigned) ptrc;
printf("%u\n",a);
printf("%u\n",b);
printf("%u\n",c);
}
return 0;
}
