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;
	}
}
Beispiel #4
0
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 ;
}
Beispiel #5
0
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;
}
Beispiel #9
0
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;
}
Beispiel #10
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;
}
Beispiel #13
0
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;
}