//Compacta el SWAP
void compactar_swap(){
log_trace(loggerManager,"[Compactación] Iniciando...");
simular_espera(config_swap->retardo_compactacion);
int index;
int cantidad_de_bits = bitarray_get_max_bit(paginas_bitmap);
int contador_ceros = 0;
t_program_info * un_programa;
for(index = 0 ; index < cantidad_de_bits ; index ++){
if(bitarray_test_bit(paginas_bitmap, index) && contador_ceros > 0){//1's y hubo ceros antes
un_programa = buscar_programa_por_pagina_inicial(index, lista_programas); //TODO: Verificar que al modificarlo de este lado se modifique en la lista perse, si es un puntero debería
reescribir_programa(un_programa, contador_ceros, archivo_swap, paginas_bitmap, config_swap, loggerManager);//Se reescribe el programa cantidad_ceros posiciones a la izquierda
contador_ceros = 0; //Se reinicia el contador
index = un_programa->pagina_inicial_swap + un_programa->cantidad_paginas; // Se reposiciona el index al final del programa que se movio, para seguir el algoritmo desde ahi
}else if(!bitarray_test_bit(paginas_bitmap, index)){ //0's
contador_ceros ++;
}
}
log_trace(loggerManager,"[Compactación] Finalizado");
}
int getFirstAvailableBlock(int cantPaginas)
{
//total(espacio libre fragmentado), cont(contador de espacio contiguo)
int total = 0, cont = 0, i;
for(i=0; i<bitMap->size; i++){
//si encuentro un bit en 0 (espacio libre) incremento, si no reseteo el contiguo
if(!bitarray_test_bit(bitMap,i))
{
cont++;
total++;
} else {
cont = 0;
}
//si encuentro un espacio contiguo de la cantidad de paginas pedidas, corto el for
if(cont>=cantPaginas)
{
i++;
break;
}
}
int retorna = -1;
if(cont>=cantPaginas){//si corte porque hay un espacio, devuelvo la posicion a partir de la cual esta el espacio para empezar a escribir
retorna = i-cantPaginas;
} else if(total>=cantPaginas){//si hay lugar pero fragmentado, se devuelve -2 que es el codigo para saber si se puede defragmentar
retorna = -2;
} else {//devuelve -1 si no hay espacio
retorna = -1;
}
return retorna;
}
void compactarSwap()
{
logInfo("Realizando compactacion de espacio: %d ms",config->retardo_compact);
usleep(config->retardo_compact*1000); //convierto micro en milisegundos
int ultimo_frame_disponible = 0;
int j=0;
while(j<config->cantidad_paginas){
int i;
//primer bloque disponible para empezar a compactar
int primer_frame_disponible = obtener_primer_disponible(ultimo_frame_disponible);
//busco ultimo disponible empezando desde el primero disponible
ultimo_frame_disponible = ultimo_disponible(primer_frame_disponible);
i=primer_frame_disponible;
j=ultimo_frame_disponible+1;
//Voy acomodando desde el primero disponible hasta el ultimo de ese bloque todos los ocupados que
//encuentro a partir de ahi
while(i <= ultimo_frame_disponible && j<config->cantidad_paginas)
{
if(bitarray_test_bit(bitMap,j))
{
moverFrame(j, i);
i++;
}
j++;
}
}
logInfo("Compactacion finalizada");
}
int obtener_primer_disponible(int offset)
{
//contado de espacio contiguo
int i;
for(i=offset; i<bitMap->size; i++){
//a partir del primer 0 espacio disponible
if(!bitarray_test_bit(bitMap,i)){
break;
}
}
return i;
}
void reservar_bloque_datos(ptrGBloque *blk_direct, int j)
{
int pos_bit = bits_disponibles;
while(bitarray_test_bit(bitmap, pos_bit))
{
pos_bit++;
}
bitarray_set_bit(bitmap, pos_bit);
blk_direct[j] = pos_bit;
char *bloque_dato = (char *) data_disco + blk_direct[j] * BLOCK_SIZE;
bzero(bloque_dato, BLOCK_SIZE);
return;
}
int ultimo_disponible(int primero)
{
//contado de espacio contiguo
int i;
for(i=primero; i<bitMap->size; i++){
//corta si encuentra uno ocupado
if(bitarray_test_bit(bitMap,i)){
i--;
break;
}
}
return i;
}
void reservar_bloque_directo(int pos_archivo, int i)
{
int pos_bit = bits_disponibles;
while(bitarray_test_bit(bitmap, pos_bit))
{
pos_bit++;
}
bitarray_set_bit(bitmap, pos_bit);
nodos[pos_archivo].blk_indirect[i] = pos_bit;
ptrGBloque* blk_direct = (ptrGBloque *) (data_disco + nodos[pos_archivo].blk_indirect[i] * BLOCK_SIZE);
int k;
for(k = 0; k < 1024; k++)
{
blk_direct[k] = 0;
}
return;
}
