void escribir_pagina(void *msj){
solicitudEscribirPagina *mensaje = (solicitudEscribirPagina*) msj;
log_info(logger, "[ESCRIBIR_PAGINA]: (#pid: %d) (#pagina: %d).", mensaje->pid, mensaje->pagina);
int numeroDePagina = buscarPaginaEnTablaDePaginas(mensaje->pid, mensaje->pagina);
int *respuesta = reservarMemoria(INT);
if(numeroDePagina != ERROR){
*respuesta = PERMITIDO;
aplicar_protocolo_enviar(sockUMC, RESPUESTA_PEDIDO, respuesta);
avanzarPaginas(numeroDePagina); // Desplazamiento dentro del archivo
dormir(config->retardoAcceso);
// Escribo el contenido recibido en el archivo:
fwrite(mensaje->contenido, CHAR, mensaje->tamanio_marco, archivoSwap);
}
else{
*respuesta = NO_PERMITIDO; // no encontró página en tabla de páginas
aplicar_protocolo_enviar(sockUMC, RESPUESTA_PEDIDO, respuesta);
}
free(mensaje->contenido); mensaje->contenido = NULL;
free(mensaje); mensaje = NULL;
free(respuesta); respuesta = NULL;
}
void inicializarTablaBitMap() {
tablaDeBitMap = reservarMemoria(sizeof(t_bitMap) * config->cantidadPaginas);
int i;
for(i=0; i < config->cantidadPaginas; i++){
tablaDeBitMap[i].ocupada = 0;
}
}
void inicializarTablaDePaginas() {
tablaPaginas = reservarMemoria(sizeof(t_tablaDePaginas) * config->cantidadPaginas);
int i;
for (i=0; i < config->cantidadPaginas; i++) {
tablaPaginas[i].pid=-1;
tablaPaginas[i].pagina=-1;
}
}
Barquitos::Barquitos(const int filas, const int columnas){
nfil = filas ;
ncol = columnas ;
reservarMemoria(nfil, ncol) ;
for(int i = 0 ; i < nfil ; i++)
for(int j = 0 ; j < ncol ; j++)
datos[i][j] = agua ;
}
const Barquitos & Barquitos::operator = (const Barquitos &otro){
if(this != &otro){
liberarMemoria() ;
reservarMemoria(otro.nfil, otro.ncol) ;
copiarDatos(otro) ;
}
return *this ;
}
// Funciones
void setearValores_config(t_config * archivoConfig) {
config = reservarMemoria(sizeof(t_configuracion));
config->puerto = config_get_int_value(archivoConfig, "PUERTO_ESCUCHA");
config->nombreSwap = strdup(config_get_string_value (archivoConfig, "NOMBRE_SWAP"));
config->cantidadPaginas = config_get_int_value(archivoConfig, "CANTIDAD_PAGINAS");
config->tamanioPagina = config_get_int_value(archivoConfig, "TAMANIO_PAGINA");
config->retardoCompactacion = config_get_int_value(archivoConfig, "RETARDO_COMPACTACION");
config->retardoAcceso = config_get_int_value(archivoConfig , "RETARDO_ACCESO");
}
void eliminar_programa(void *msj){
dormir(config->retardoAcceso);
int *respuesta = reservarMemoria(INT);
*respuesta = PERMITIDO;
// casteo pid
int pid = *((int*) msj);
log_info(logger ,"[ELIMINAR_PROGRAMA]: (#pid: %d).", pid);
free(msj); msj = NULL;
// busco primer aparición del pid en tabla de páginas
int aPartirDe = buscarAPartirDeEnTablaDePaginas(pid);
if(aPartirDe == ERROR){
*respuesta = NO_PERMITIDO; // no encontró página
} else {
// cuento total de páginas
int totalPaginas = 0;
int posicion = aPartirDe;
while(tablaPaginas[posicion].pid == pid){
totalPaginas++;
posicion++;
}
// repito como cantidad de páginas tenga el proceso
int i;
for(i=0; i < totalPaginas; i++){
// posiciono puntero del archivo en inicio de página
int pagina = i + aPartirDe;
avanzarPaginas(pagina);
// actualizo tabla de páginas
tablaPaginas[pagina].pid = -1;
// actualizo bitmap
tablaDeBitMap[pagina].ocupada = 0;
// escribo '\0' en paginas del proceso
char caracter = '\0';
int i;
for(i=0; i < config->tamanioPagina; i++){
fwrite(&caracter, CHAR, CHAR, archivoSwap);
}
}
// acutalizo contador global
paginasLibresTotales += totalPaginas;
}
aplicar_protocolo_enviar(sockUMC, RESPUESTA_PEDIDO, respuesta);
free(respuesta); respuesta = NULL;
}
/* Funcionamiento:
* copia la pagina de arrancaProceso a posLibre
* posLibre++, arrancaProceso++
* repetir cantidadDePaginasDelProceso
* */
void mover(int posLibre, int arrancaProceso, int cantidadDePaginasDelProceso) {
char *contenido = reservarMemoria(config->tamanioPagina);
int i;
for(i=0; i < cantidadDePaginasDelProceso ; i++){
int pid = tablaPaginas[arrancaProceso].pid;
int pagina = tablaPaginas[arrancaProceso].pagina;
int pagABuscar = buscarPaginaEnTablaDePaginas(pid , pagina); // busco posicion para leer pagina
if(pagABuscar != ERROR) avanzarPaginas(pagABuscar); // avanzo puntero a inicio de pagina
fread(contenido, CHAR, config->tamanioPagina, archivoSwap);
// actualizo tablaPaginas
tablaPaginas[posLibre].pid = pid;
tablaPaginas[posLibre].pagina = pagina;
tablaPaginas[arrancaProceso].pid= -1;
tablaPaginas[arrancaProceso].pagina = -1;
// actualizo bitmap
tablaDeBitMap[posLibre].ocupada = 1;
tablaDeBitMap[arrancaProceso].ocupada = 0;
// escribo página de proceso en página libre
avanzarPaginas(posLibre);
fwrite(contenido, CHAR, config->tamanioPagina, archivoSwap);
// escribo \0 en la página arrancaProceso
char caracter = '\0';
int i;
for(i=0; i < config->tamanioPagina; i++){
fwrite(&caracter, CHAR, CHAR, archivoSwap);
}
//actualizo contadores
posLibre++;
arrancaProceso++;
}
free(contenido); contenido = NULL;
}
int main(int argc, char *argv[])
{
key_t llave = 2032;
int shmId;
char *datos;
if (argc != 2) {
fprintf(stderr, "Error: Ingresar la cantidad de lineas\n");
exit(1);
}
shmId = reservarMemoria(llave, atoi(argv[1]));
datos = vincularMemoria(shmId);
desvincularMemoria(shmId, datos);
return 0;
}
bool Barquitos::Leer(const char *nombre){
ifstream input ;
string magica ;
int filas, columnas ;
int valor ;
input.open(nombre, ios::in | ios::binary) ;
if(!input){
cerr << "\nError en la apertura de " << nombre ;
return false ;
}
input >> magica ;
if(magica.compare("MP-BARQ-V1.0") != 0){
cerr << "\nIdentificador incorrecto." << endl ;
return false ;
}
else{
input >> filas >> columnas ;
input.ignore(1) ;
liberarMemoria() ;
reservarMemoria(filas,columnas) ;
nfil = filas ;
ncol = columnas ;
for(int i = 0 ; i < nfil ; i++)
for(int j = 0 ; j < ncol ; j++){
input.read((char*) (&valor), sizeof (int));
datos[i][j] = valor ;
}
}
input.close() ;
return true ;
}
int main(int argc, char** argv) {
if(argc != 2){
puts("No se ingreso la ruta del archivo de configuracion\n");
return 0;
}
thread_socket= 3030;
paginaEncontrada=TRUE;
umclog=malloc(sizeof(t_log));
memcpy(umclog,log_create("umc.log", "UMC", TRUE, LOG_LEVEL_TRACE), sizeof(t_log));
leerArchivoDeConfiguracion(argv[1]);
crearLogger(0);
log_info(umclog, "Inicio UMC.");
pthread_t hiloComandos;
pthread_attr_t attrhiloComandos;
memoriaReal = reservarMemoria(marcos, marco_Size); //Fabrico mi memoria real
iniciarEstructurasUMC();
socketSwap=socketCreateClient();
socketConnect(socketSwap,ip_Swap,atoi(puerto_Swap));
menuUMC(hiloComandos, attrhiloComandos);
manageSocketConnections();
liberarMemoria(memoriaReal); //Una vez terminado, libero toda mi memoria real
log_destroy(logger);
return EXIT_SUCCESS;
}
void leer_pagina(void *msj) {
solicitudLeerPagina *mensaje = (solicitudLeerPagina*) msj;
int pid = mensaje->pid;
int pagina = mensaje->pagina;
log_info(logger ,"[LEER_PAGINA]: (#pid: %d) (#pagina: %d).", pid, pagina);
free(mensaje); mensaje = NULL;
int pagABuscar = buscarPaginaEnTablaDePaginas(pid , pagina);
int *respuesta = reservarMemoria(INT);
if(pagABuscar != ERROR){ // Encontró página solicitada del proceso:
*respuesta = PERMITIDO;
aplicar_protocolo_enviar(sockUMC, RESPUESTA_PEDIDO, respuesta);
avanzarPaginas(pagABuscar);
dormir(config->retardoAcceso);
// Cargo en la página a devolver el contenido leído del archivo:
paginaSwap* pagina_swap = malloc(sizeof(paginaSwap));
pagina_swap->tamanio_marco = config->tamanioPagina;
pagina_swap->contenido = malloc(config->tamanioPagina);
fread(pagina_swap->contenido, CHAR, config->tamanioPagina, archivoSwap);
aplicar_protocolo_enviar(sockUMC, DEVOLVER_PAGINA, pagina_swap);
free(pagina_swap->contenido); pagina_swap->contenido = NULL;
free(pagina_swap); pagina_swap = NULL;
}
else{ // No encontró página solicitada del proceso:
*respuesta = NO_PERMITIDO;
aplicar_protocolo_enviar(sockUMC, RESPUESTA_PEDIDO, respuesta);
}
free(respuesta); respuesta = NULL;
}
int main(int argc, char *argv[]){
if (argc != 1) {
fprintf(stderr, "Error: Ingresar los parametros. Forma correcta: ./%s\n", argv[0]);
exit(1);
}
/* Abre la bitacora */
archivoBitacora = open(NOMBREBITACORA, O_WRONLY|O_APPEND,S_IRUSR|S_IWUSR);
/* Crea el semaforo de la bitacora */
semarofoArchivo = crearSemarofoArchivo(NOMBREBITACORA);
/* Solicita el algoritmo que se quiere utilizar */
tipoAlgoritmo = escogerAlgoritmo();
/* Key del semaforo de la memoria */
key_t llaveSemarofo = 2032;
key_t llaveSemarofoLectura = 1395;
key_t llaveSemarofoBloqueado = 2186;
key_t llaveSemarofoAcceso = 5068;
/* Keys para reservar los segmentos de memoria */
key_t llaveDatos = 5432;
key_t llaveTamano = 6543;
key_t llaveBandera = 7654;
key_t llaveBloqueado = 6667;
key_t llaveAccesoMem = 4565;
int shmIdDatos;
int shmIdTamano;
int shmIdBandera;
int shmIdBloqueado;
int shmIdAccesoMem;
int *bandera;
/* Solicita la memoria del tamano */
shmIdTamano = reservarMemoria(llaveTamano, 1);
tamano = vincularMemoria(shmIdTamano);
/* Solicita la memoria de la bandera */
shmIdBandera = reservarMemoria(llaveBandera, 1);
bandera = vincularMemoria(shmIdBandera);
/* Solicita la memoria de los datos */
shmIdDatos = reservarMemoria(llaveDatos, (int)*tamano);
datos = vincularMemoria(shmIdDatos);
/* Solicita la memoria de los bloqueados */
shmIdBloqueado = reservarMemoria(llaveBloqueado, MEMORIABLOQUEADO);
bloqueado = vincularMemoria(shmIdBloqueado);
/* Solicita la memoria de el proceso que acede a memoria */
shmIdAccesoMem = reservarMemoria(llaveAccesoMem, 1);
accesoMemoria = vincularMemoria(shmIdAccesoMem);
/* Inicializamos los semaforo */
semaforoId = crearSemaforoMemoria(llaveSemarofo);
semaforoIdBloqueado = crearSemaforoMemoria(llaveSemarofoBloqueado);
semaforoIdLectura = crearSemaforoMemoria(llaveSemarofoLectura);
semaforoIdAcceso = crearSemaforoMemoria(llaveSemarofoAcceso);
/* Crea los hilos */
producirHilos(bandera);
/* destruimos el semaforo */
destruirSemaforoMemoria(semaforoId);
destruirSemaforoMemoria(llaveSemarofoBloqueado);
destruirSemaforoMemoria(semaforoIdLectura);
destruirSemaforoMemoria(semaforoIdAcceso);
close(archivoBitacora);
return 0;
}
void iniciar_programa(void *msj) {
int *respuesta = reservarMemoria(INT);
*respuesta = PERMITIDO;
inicioPrograma *mensaje = (inicioPrograma*) msj;
int pid = mensaje->pid;
int paginas = mensaje->paginas;
log_info(logger, "[INICIAR_PROGRAMA]: (#pid: %d) (#paginas: %d).", pid, paginas);
if(paginasLibresTotales >= paginas) { // se puede alojar el proceso aunque sea compactando
int posLibre = buscarPosLibresEnBitMap(paginas);
if(posLibre != ERROR) { // se encontraron espacios contiguos para alojar proceso
paginasLibresTotales -= paginas;
int pagina;
for(pagina=0; pagina < paginas ; pagina++) {
tablaPaginas[posLibre].pid = pid;
tablaPaginas[posLibre].pagina = pagina;
tablaDeBitMap[posLibre].ocupada = 1;
posLibre++;
}
} else { // no se encontraron espacios contiguos para alojar proceso
dormir(config->retardoCompactacion);
compactar();
actualizarBitMap();
int posLibre = buscarPosLibresEnBitMap(paginas);
int pagina;
for(pagina=0; pagina < paginas; pagina++) {
tablaPaginas[posLibre].pid= pid;
tablaPaginas[posLibre].pagina = pagina;
tablaDeBitMap[posLibre].ocupada=1;
posLibre++;
}
paginasLibresTotales -= paginas;
}
} else {
log_info(logger, "[Programa Rechazado]");
*respuesta = NO_PERMITIDO; // no hay paginas disponibles para satisfacer la demanda
}
if(*respuesta == PERMITIDO) {
log_info(logger, "[Programa Aceptado]");
int pos = buscarPaginaEnTablaDePaginas(pid, 0);
avanzarPaginas(pos);
dormir(config->retardoAcceso);
// Escribo la totalidad del código en el archivo:
fwrite(mensaje->contenido, CHAR, strlen(mensaje->contenido), archivoSwap);
}
free(mensaje->contenido); mensaje->contenido = NULL;
free(mensaje); mensaje = NULL;
aplicar_protocolo_enviar(sockUMC, RESPUESTA_PEDIDO, respuesta);
free(respuesta); respuesta = NULL;
}