//Testeada
void funcionHiloQuantum() {
for (;;) {
verificarModificacionesArchivoConfig();
usleep(3);
leerArchivoDeConfiguracion(rutaArchivoConfig);
printf("Valores Seteados Nuevamente.\n");
}
}
//se ejecuta al comienzo del suite
static int init_suite() {
int a_rgc = 3;
char* temp = string_new();
string_append(&temp,
"./CPU;/home/utnso/tp-2015-2c-tpso/CPU/config_cpu.cfg;test");
char** a_rgv = string_split(temp, ";");
a_rgc = 3;
leerArchivoDeConfiguracion(a_rgc, a_rgv);
procCPU = crearProcCPU();
return 0;
}
int main(int argc, char *argv[]) {
procesarParametros(argc, argv);
procCPU = crearProcCPU();
logger = log_create("LOG_CPU.log", "CPU", false, LOG_LEVEL_INFO); //Inicializacion logger
if (hayQueEjecutarTests(argc, argv)) {
return ejecutarTests();
}
leerArchivoDeConfiguracion(argc, argv);
levantarHilosCPU();
destProcCPU(procCPU);
return EXIT_SUCCESS;
}
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;
}
int main(int argc, char **argv){
system("clear");
setvbuf(stdout, NULL, _IONBF, 0);
validar_argumentos(argc);
crearLoggerConsola();
leerArchivoDeConfiguracion(RUTA_CONFIG_CONSOLA);
leerScript(argv[1]);
conectarCon_Nucleo(); // Conexión con Núcleo
aplicar_protocolo_enviar(fd_nucleo, ENVIAR_SCRIPT, programa);
log_info(logger, "Script enviado a Núcleo. Esperando respuesta.");
int head;
void * mensaje = NULL;
mensaje = aplicar_protocolo_recibir(fd_nucleo, &head); // Recibo respuesta de incio programa
if (head == PROGRAMA_NEW){
switch(*((int*) mensaje)){
case RECHAZADO:{ // programa rechazado
log_info(logger, "UMC no pudo alocar los segmentos pedidos. Programa rechazado.");
free(mensaje); mensaje = NULL;
exitConsola();
return EXIT_FAILURE;
break;
} // fin case rechazado
case ERROR_CONEXION:{
log_error(logger, "Error al iniciar programa. Script no enviado.");
free(mensaje); mensaje = NULL;
exitConsola();
return EXIT_FAILURE;
break;
} // fin case error conexión
case ACEPTADO:{ // programa aceptado
log_info(logger, "Programa aceptado. Escuchando nuevos mensajes de Núcleo.");
while(TRUE){ // Espera activa de mensajes
int protocolo;
void * entrada = NULL;
entrada = aplicar_protocolo_recibir(fd_nucleo, &protocolo);
if(entrada == NULL) break;
switch(protocolo){
case IMPRIMIR_TEXTO:{
// Imprime lo que recibe, ya sea texto a variable (convertida a texto):
printf(">> IMPRIMIR: '%s'.\n", (char*) entrada);
free(entrada); entrada = NULL;
break;
}
case FINALIZAR_PROGRAMA:{
int respuesta = *((int*)entrada);
if(respuesta == PERMITIDO) {
log_info(logger, "El programa ha finalizado con éxito.");
} else {
log_error(logger, "El programa ha sido abortado.");
}
free(entrada); entrada = NULL;
free(mensaje); mensaje = NULL;
exitConsola();
return EXIT_SUCCESS;
break;
}
} // fin switch-case nuevos mensajes
} // fin while espera mensajes
break;
} // fin case aceptado
} // fin switch respuesta inicio
} // fin if head válido
free(mensaje); mensaje = NULL;
exitConsola();
return EXIT_FAILURE;
} // fin main
//testeada
int inicializarVariables(char* ruta) {
// LOG
nucleolog = malloc(sizeof(t_log));
//nucleolog = log_create("nucleo.log", "NUCLEO", 1, LOG_LEVEL_INFO);
memcpy(nucleolog, log_create("nucleo.log", "NUCLEO", 1, LOG_LEVEL_INFO),
sizeof(t_log));
//tamanioPaginas=pedirTamanioDePagina();
//Variables de lectura de archivo
puertoPropio = (char*) malloc(sizeof(puertoPropio));
cpuPort = (char*) malloc(sizeof(cpuPort));
quantum = (int) malloc(sizeof(quantum));
quantumSleep = (int) (sizeof(quantumSleep));
idSemaforos = (char**) malloc(sizeof(idSemaforos));
viSemaforos = (char**) malloc(sizeof(viSemaforos));
cantSemaforos = (int) malloc(sizeof(cantSemaforos)); //No se lee por config
idIO = (char**) malloc(sizeof(idIO));
retardoIO = (char**) malloc(sizeof(retardoIO));
int cantIO = (int) malloc(sizeof(cantIO)); //No se lee por config
idVariableCompartida = (char**) malloc(sizeof(idVariableCompartida));
cantVarCompartidas = (int) malloc(sizeof(cantVarCompartidas));
//variableCompartidaValor=(int*)malloc(sizeof(variableCompartidaValor));
ipUMC = (char*) malloc((sizeof(ipUMC)));
UMCPort = (char*) malloc((sizeof(UMCPort)));
stackSize = (int) malloc((sizeof(stackSize)));
tamanioPaginas = (int) malloc((sizeof(tamanioPaginas)));
//Otras Variables
idProgramas = (int) malloc(sizeof(idProgramas)); //Contador de programa
primeraLectura = (bool) malloc(sizeof(primeraLectura));
//Sincronizacion
//pthread_mutex_t** mutexIO;
//pthread_mutex_t** mutexVariables;
mutexQuantum = malloc(sizeof(pthread_mutex_t));
mutexColaNew = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexColaReady = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexColaExit = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexListaExec = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexListaBlock = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
mutexListaCpu = (pthread_mutex_t*) malloc(sizeof(pthread_mutex_t));
primeraLectura = true;
int i;
//Leo el archivo de configuracion
leerArchivoDeConfiguracion(ruta);
//Inicio Semaforos
cantSemaforos = cantidadPalabrasEnArrayDeStrings(idSemaforos);
char* valorInicial;
//char algo;
unsigned int algo2 = 0;
//sem_t semaforoPrueba;
//sem_init(&semaforoPrueba, 0, 4);
//semaforosAnsisop=malloc(sizeof(pthread_mutex_t)*cantSemaforos);
for (i = 0; i < cantSemaforos; i++) {
valorInicial = viSemaforos[i];
//algo=*valorInicial;
algo2 = atoi(valorInicial);
semaforosAnsisop[i] = malloc(sizeof(sem_t));
if (sem_init((semaforosAnsisop[i]), 0, algo2) != 0) {
printf("\n init semaforoAnsisop %d fallo\n", i);
return -1;
}
}
//Inicio Semaforos de Sincro
//inicio cantIO
cantidadDispositivosIO = malloc(sizeof(int));
cantIO = cantidadPalabrasEnArrayDeStrings(idIO);
memcpy(cantidadDispositivosIO,&cantIO,sizeof(int));
//mutexIO=malloc(sizeof(pthread_mutex_t)*cantIO);
for (i = 0; i < cantIO; i++) {
mutexIO[i] = malloc(sizeof(pthread_mutex_t));
if (pthread_mutex_init(mutexIO[i], NULL) != 0) {
printf("\n init mutexIO %d fallo\n", i);
return -1;
}
}
//inicio cantVarsCompartidas
cantVarCompartidas = cantidadPalabrasEnArrayDeStrings(idVariableCompartida);
variableCompartidaValor = (int*) malloc(sizeof(int) * cantVarCompartidas);
for (i = 0; i < cantVarCompartidas; i++) {
variableCompartidaValor[i] = 0;
}
//mutexVariables=malloc(sizeof(pthread_mutex_t)*cantVarCompartidas);
for (i = 0; i < cantVarCompartidas; i++) {
mutexVariables[i] = malloc(sizeof(pthread_mutex_t));
if (pthread_mutex_init(mutexVariables[i], NULL) != 0) {
printf("\n init mutexVariables %d fallo\n", i);
return -1;
}
}
if (pthread_mutex_init(mutexListaCpu, NULL) != 0) {
printf("\n init mutexListaCpu fallo\n");
return -1;
}
if (pthread_mutex_init(mutexQuantum, NULL) != 0) {
printf("\n init mutexQuamtum fallo\n");
return -1;
}
if (pthread_mutex_init(mutexColaNew, NULL) != 0) {
printf("\n init mutexCOlaNew fallo\n");
return -1;
}
if (pthread_mutex_init(mutexColaReady, NULL) != 0) {
printf("\n init mutexColaReady fallo\n");
return -1;
}
if (pthread_mutex_init(mutexColaExit, NULL) != 0) {
printf("\n init mutexColaExit fallo\n");
return -1;
}
if (pthread_mutex_init(mutexListaBlock, NULL) != 0) {
printf("\n init mutexListaBlock fallo\n");
return -1;
}
if (pthread_mutex_init(mutexListaExec, NULL) != 0) {
printf("\n init mutexListaExec fallo\n");
return -1;
}
//inicio El contador de ids
idProgramas = 0;
//InicioLasColas
listaNew = list_create();
//colaNew = queue_create();
listaReady = list_create();
//colaReady = queue_create();
listaExec = list_create();
listaBlock = list_create();
listaExit = list_create();
//colaExit = queue_create();
listaCpu = list_create();
umcServer = socketCreateClient();
do {
puts("**********************************");
puts("Intentando conectar con la UMC ppal.");
printf("IP: %s, PUERTO: %d\n", ipUMC, atoi(UMCPort));
sleep(3);
} while (!socketConnect(umcServer, ipUMC, atoi(UMCPort)));
StrKerUmc* out_umc_msg = newStrKerUmc(KERNEL_ID, HANDSHAKE, NULL, 0, 0, 0,
0, 0, 0);
SocketBuffer* sb = serializeKerUmc(out_umc_msg);
socketSend(umcServer->ptrSocket, sb);
puts("Mensaje enviado a la UMC ppal.");
sb = socketReceive(umcServer->ptrSocket);
StrUmcKer* in_umc_msg = unserializeUmcKer(sb);
printf("Nuevo UMC es %d.\n", in_umc_msg->size);
int nuevoPuertoUmc = in_umc_msg->size;
tamanioPaginas = pedirTamanioDePagina(nuevoPuertoUmc);
return 0;
}
