void test_throughput()
{
struct bitarray* bits;
struct timeval start, end;
char pretty_time[32];
uint64_t i, time;
bits = bitarray_init(4294967296);
for (i = 0; i < 4294967296; i++)
{
bitarray_set_bit(bits, i);
}
gettimeofday(&start, NULL);
for (i = 0; i < 4294967296; i++)
{
assert(bitarray_get_bit(bits, i) == true);
}
gettimeofday(&end, NULL);
time = diff_time(start, end);
pretty_print_microseconds(time, pretty_time, 32);
fprintf_cyan(stdout, "time to get 4294967296 items and check set: %s\n",
pretty_time);
bitarray_destroy(bits);
}
int main(int argc, char* argv[])
{
uint64_t i;
struct bitarray* bits;
fprintf_blue(stdout, "-- Bitarray Test Suite --\n");
fprintf_light_blue(stdout, "* test bitarray_init()\n");
bits = bitarray_init(8*512);
bitarray_print(bits);
fprintf_light_blue(stdout, "* test bitarray_set_all()\n");
bitarray_set_all(bits);
bitarray_print(bits);
fprintf_light_blue(stdout, "* test bitarray_clear()\n");
bitarray_unset_all(bits);
bitarray_print(bits);
fprintf_light_blue(stdout, "* test bitarray_set_bit()\n");
for (i = 0; i < 31; i++)
{
bitarray_set_bit(bits, test_nums[i]);
}
fprintf_light_blue(stdout, "* test bitarray_get_bit()\n");
for (i = 0; i < 31; i++)
{
assert(bitarray_get_bit(bits, test_nums[i]) == true);
}
fprintf_light_blue(stdout, "* test bitarray_unset_bit()\n");
bitarray_unset_bit(bits, test_nums[4]);
bitarray_unset_bit(bits, test_nums[9]);
for (i = 0; i < 31; i++)
{
if (i == 4 || i == 9) continue;
assert(bitarray_get_bit(bits, test_nums[i]) == true);
}
for (i = 0; i < 31; i++)
{
bitarray_unset_bit(bits, test_nums[i]);
}
for (i = 0; i < 31; i++)
{
assert(bitarray_get_bit(bits, test_nums[i]) == false);
}
bitarray_print(bits);
bitarray_destroy(bits);
test_throughput();
return EXIT_SUCCESS;
}
int main(void) {
loggerManager = log_create("swap.log","SWAP", true, LOG_LEVEL_TRACE); //creo un archivo log
/******************************** Configuraciones SWAP ********************************/
config_swap = malloc(sizeof(t_config_swap));
config_swap->nombre_swap = malloc(30);
cargar_configuracion_swap("config.swap.ini",config_swap);
log_trace(loggerManager, "\nSe cargaron las configuraciones con los siguientes valores: \nPUERTO_ESCUCHA=%i \nNOMBRE_SWAP=%s\nCANTIDAD_PAGINAS=%i\nTAMANO_PAGINA=%i\nRETARDO_COMPACTACION=%i\nRETARDO_ACCESO=%i\n", config_swap->puerto_escucha, config_swap->nombre_swap, config_swap->cantidad_paginas, config_swap->tamano_pagina, config_swap->retardo_compactacion, config_swap->retardo_acceso);
/***************************************************************************************/
/*********************************** Archivo SWAP ***********************************/
int status = crear_archivo_swap(config_swap->nombre_swap, config_swap->cantidad_paginas * config_swap->tamano_pagina); //creo e inicializo el archivo SWAP
if(status!=-1)
log_trace(loggerManager,"Se creo correctamente el archivo swap");
else
log_error(loggerManager,"Hubo un problema al intentar crear el archivo swap");
archivo_swap = fopen(config_swap->nombre_swap, "rb+");
/**************************************************************************************/
/****************************** Estructuras de control ******************************/
float tamano_paginas_array;
if((config_swap->cantidad_paginas) % 8 == 0)
tamano_paginas_array = (config_swap->cantidad_paginas) / 8;
else
tamano_paginas_array = (config_swap->cantidad_paginas) / 8 + 1;
char paginas_array[(int) tamano_paginas_array]; //Divido por 8 porque cada char tiene 8 bits (1 byte), creo que funciona asi la cosa //TODO: verificar los ultimos cambios
paginas_bitmap = bitarray_create(paginas_array, sizeof paginas_array); //Creo el bitmap
inicializar_bitmap(paginas_bitmap); //Inicializo el bitmap en 0 (false)
log_trace(loggerManager,"Se creo e inicializo la estructura bitmap con %d cantidad de bits", bitarray_get_max_bit(paginas_bitmap));
lista_programas = list_create(); //Aca voy a meter los t_program_info a medida que el umc me pida crear un programa
/**************************************************************************************/
/************************************ Server SWAP ************************************/
t_configuracion_servidor *servidor_swap_config = malloc(sizeof(t_configuracion_servidor));
servidor_swap_config->puerto = config_swap->puerto_escucha;
servidor_swap_config->funcion = atender_UMC; //No deberia hacer falta el & pero ojo
//servidor_swap_config->parametros_funcion = config_swap;
crear_servidor(servidor_swap_config);
log_trace(loggerManager,"Se establecio el SWAP como servidor");
/**************************************************************************************/
getchar(); //pausa
/****************************** Liberacion de recursos *******************************/
fclose(archivo_swap);
log_destroy(loggerManager);
free(config_swap->nombre_swap);
free(config_swap);
free(servidor_swap_config);
bitarray_destroy(paginas_bitmap);
list_destroy(lista_programas);
/***************************************************************************************/
return EXIT_SUCCESS;
}
int read_loop(int fd, struct kv_store* handle, struct bitarray* bits)
{
struct timeval start, end;
uint8_t buf[QEMU_HEADER_SIZE];
int64_t total = 0, read_ret = 0;
struct qemu_bdrv_write write;
size_t len = QEMU_HEADER_SIZE;
uint64_t counter = 0;
write.data = (uint8_t*) malloc(4096);
if (write.data == NULL)
{
fprintf_light_red(stderr, "Failed initial alloc for write.data.\n");
return EXIT_FAILURE;
}
while (1)
{
gettimeofday(&start, NULL);
read_ret = read(fd, buf, QEMU_HEADER_SIZE);
total = read_ret;
while (read_ret > 0 && total < QEMU_HEADER_SIZE)
{
read_ret = read(fd, &buf[total], QEMU_HEADER_SIZE - total);
total += read_ret;
}
/* check for EOF */
if (read_ret == 0)
{
fprintf_light_red(stderr, "Total read: %"PRId64".\n", total);
fprintf_light_red(stderr, "Reading from stream failed, assuming "
"teardown.\n");
return EXIT_SUCCESS;
}
if (read_ret < 0)
{
fprintf_light_red(stderr, "Unknown fatal error occurred, 0 bytes"
"read from stream.\n");
return EXIT_FAILURE;
}
qemu_parse_header(buf, &write);
len = write.header.nb_sectors * SECTOR_SIZE;
write.data = (uint8_t*) realloc(write.data, len);
if (write.data == NULL)
{
fprintf_light_red(stderr, "realloc() failed, assuming OOM.\n");
fprintf_light_red(stderr, "tried allocating: %d bytes\n",
write.header.nb_sectors*SECTOR_SIZE);
return EXIT_FAILURE;
}
read_ret = read(fd, (uint8_t*) write.data,
write.header.nb_sectors*SECTOR_SIZE);
total = read_ret;
while (read_ret > 0 && total < write.header.nb_sectors*SECTOR_SIZE)
{
read_ret = read(fd, (uint8_t*) &write.data[total],
write.header.nb_sectors*SECTOR_SIZE - total);
total += read_ret;
}
if (read_ret <= 0)
{
fprintf_light_red(stderr, "Stream ended while reading sector "
"data.\n");
return EXIT_FAILURE;
}
/* the mountain of things i still regret ! */
if (redis_async_write_enqueue(handle, bits, write.header.sector_num,
write.data, len))
fprintf_light_red(stderr, "\tqueue would block: dropping write\n");
gettimeofday(&end, NULL);
fprintf(stderr, "[%"PRIu64"]read_loop finished in %"PRIu64
" microseconds [%d bytes]\n", counter++,
diff_time(start, end),
write.header.nb_sectors*SECTOR_SIZE);
}
if (write.data)
free(write.data);
if (bits)
bitarray_destroy(bits);
return EXIT_SUCCESS;
}
