int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 2) {
strcpy (buffer, "Error: Cantidad de parametros invalida\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int cantProcesos = 0;
sscanf(argv[1] , "%d", &cantProcesos);
// Creando semaforo de control de acceso a la memoria compartida
Semaphore semControl = Semaphore();
semControl.createSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1);
semControl.initializeSemaphore(0, 1);
// Creando semaforos de control de los procesos
Semaphore semProductores = Semaphore();
semProductores.createSemaphore((char *)DIRECTORY, ID_SEMPRODUCTORES, cantProcesos);
for (int nroSemaforo = 0; nroSemaforo < cantProcesos; nroSemaforo++) {
semProductores.initializeSemaphore(nroSemaforo, 1);
}
// Creando la memoria compartida
CountingSharedMemory shMem = CountingSharedMemory();
shMem.createSharedMemory((char *)DIRECTORY, ID_SHMEM);
semControl.wait(0);
{
int p = 0;
shMem.writeInfo(&p);
}
semControl.signal(0);
for (int i = 0; i < cantProcesos; i++) {
pid_t pid = fork();
if (pid == 0) {
char nroProductor[TAM_BUFFER];
sprintf(nroProductor,"%d",i);
execlp("./productor", "productor", nroProductor, argv[1], (char *) 0);
sprintf(buffer, "Launcher Error: %s\n", strerror(errno));
write(fileno(stdout), buffer, strlen(buffer));
}
//sleep (1);
}
sprintf(buffer, "Launcher Terminado \n");
write(fileno(stdout), buffer, strlen(buffer));
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 3) {
strcpy (buffer, "Launcher: Error: Cantidad de parametros invalida\n Uso:\n ./launcher [CANT BUSES] [CANT PERSONAS]\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
int cantBuses = 0;
sscanf(argv[1] , "%d", &cantBuses);
if (cantBuses > MAX_BUSES) {
sprintf (buffer, "Launcher: Error: Cantidad de buses debe ser menor que %d\n", MAX_BUSES);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
int cantPersonas = 0;
sscanf(argv[2] , "%d", &cantPersonas);
sprintf(buffer, "Launcher: Cantidad buses: %d Cantidad Personas: %d\n", cantBuses, cantPersonas);
write(fileno(stdout), buffer, strlen(buffer));
Semaphore semControlSala = Semaphore();
Semaphore semPuerta = Semaphore();
Semaphore semBuses = Semaphore();
IntercambioMessageQueue intercambioMessageQueue = IntercambioMessageQueue();
InfoSalaSharedMemory shMemSala = InfoSalaSharedMemory();
try {
// Creando semaforo de control de acceso a la memoria compartida Sala
semControlSala.createSemaphore((char *)DIRECTORY, ID_SEM_CONTROL_SALA, 1);
semControlSala.initializeSemaphore(0, 1);
// Creando semaforo de bloqueo de la puerta
semPuerta.createSemaphore((char *)DIRECTORY, ID_SEM_PUERTA, 1);
semPuerta.initializeSemaphore(0, 0);
// Creando semaforo de bloqueo de buses
semBuses.createSemaphore((char *)DIRECTORY, ID_SEM_BUSES, cantBuses);
for (int i = 0; i < cantBuses; ++i) {
semBuses.initializeSemaphore(i, 0);
}
for (int i = 0; i < cantBuses; ++i) {
semBuses.signal(i);
sprintf(buffer, "Launcher: Probando sem bus: %d\n", i);
write(fileno(stdout), buffer, strlen(buffer));
semBuses.wait(i);
sprintf(buffer, "Launcher 2: Probando sem bus: %d\n", i);
write(fileno(stdout), buffer, strlen(buffer));
}
// Creando la cola de mensajes de intercambio
intercambioMessageQueue.create((char*)DIRECTORY, ID_COLA_PERSONAS);
// Creando memoria compartida Sala
shMemSala.createSharedMemory((char *)DIRECTORY, ID_SHMEM_SALA);
InfoSala informacionSala;
informacionSala.puertaBloqueada = false;
informacionSala.busEnSala = false;
for (int i = 0; i < TAM_SALA; ++i) {
informacionSala.idPersonas[i] = 0;
}
for (int i = 0; i < cantBuses; ++i) {
informacionSala.busBloqueado[i] = false;
}
semControlSala.wait(0);
{
shMemSala.writeInfo(&informacionSala);
}
semControlSala.signal(0);
}
catch (IPCException &ex) {
sprintf (buffer, "Launcher Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Creando Buses
static char cantidadBuses[TAM_BUFFER];
sprintf(cantidadBuses, "%d",cantBuses);
for (int i = 0; i < cantBuses; i++) {
static char nroBus[TAM_BUFFER];
sprintf(nroBus,"%d",i);
pid_t pid = fork();
if (pid == 0) {
execlp("./bus", "bus", nroBus, cantidadBuses, (char *) 0);
sprintf(buffer, "Launcher Bus: Error: %s\n", strerror(errno));
write(fileno(stderr), buffer, strlen(buffer));
}
}
// Creando Puerta
pid_t pid = fork();
if (pid == 0) {
execlp("./puerta", "puerta", (char *) 0);
sprintf(buffer, "Launcher Puerta: Error: %s\n", strerror(errno));
write(fileno(stderr), buffer, strlen(buffer));
}
// Creando Productor de personas
static char cantidadPersonas[TAM_BUFFER];
sprintf(cantidadPersonas, "%d",cantPersonas);
pid = fork();
if (pid == 0) {
execlp("./productor", "productor", cantidadPersonas, (char *) 0);
sprintf(buffer, "Launcher Productor: Error: %s\n", strerror(errno));
write(fileno(stderr), buffer, strlen(buffer));
}
sprintf(buffer, "Launcher: Terminado \n");
write(fileno(stdout), buffer, strlen(buffer));
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 3) {
strcpy (buffer, "Launcher: Error: Cantidad de parametros invalida\n Uso:\n ./launcher [CANT PUERTAS] [CANT MAXIMA]\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int cantPuertas = 0;
sscanf(argv[1] , "%d", &cantPuertas);
int cantMaxima = 0;
sscanf(argv[2] , "%d", &cantMaxima);
sprintf(buffer, "Launcher: Puertas: %d Cantidad maxima: %d\n", cantPuertas, cantMaxima);
write(fileno(stdout), buffer, strlen(buffer));
// Creando semaforo de control de acceso a la memoria compartida
Semaphore semControl = Semaphore();
if (semControl.createSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1) != 0) {
sprintf(buffer, "Launcher Error: El semaforo de control de acceso ya existe\n");
write(fileno(stdout), buffer, strlen(buffer));
exit(-1);
}
semControl.initializeSemaphore(0, 1);
// Creando memoria compartida
InfoMuseoSharedMemory shMem = InfoMuseoSharedMemory();
if (shMem.createSharedMemory((char *)DIRECTORY, ID_SHMEM) != 0) {
sprintf(buffer, "Launcher Error: La memoria compartida ya existe\n");
write(fileno(stdout), buffer, strlen(buffer));
exit(-1);
}
InfoMuseo initialInfo;
initialInfo.abierto = false;
initialInfo.cantidad = 0;
initialInfo.total = 0;
initialInfo.cantidadMaxima = cantMaxima;
semControl.wait(0);
{
shMem.writeInfo(&initialInfo);
}
semControl.signal(0);
// Creando puertas entrada
for (int i = 1; i <= cantPuertas; i++) {
pid_t pid = fork();
if (pid == 0) {
static char nroPuerta[TAM_BUFFER];
sprintf(nroPuerta,"%d",i);
execlp("./puertaEntrada", "puertaEntrada", nroPuerta, (char *) 0);
sprintf(buffer, "Launcher Puerta Entrada: Error: %s\n", strerror(errno));
write(fileno(stdout), buffer, strlen(buffer));
}
srand(time(NULL));
int delay = (rand() % 2) + 1;
sprintf(buffer, "Launcher: Durmiendo durante %d\n", delay);
write(fileno(stdout), buffer, strlen(buffer));
sleep(delay);
}
// Creando puertas salida
for (int i = 1; i <= cantPuertas; i++) {
pid_t pid = fork();
if (pid == 0) {
static char nroPuerta[TAM_BUFFER];
sprintf(nroPuerta,"%d",i);
execlp("./puertaSalida", "puertaSalida", nroPuerta, (char *) 0);
sprintf(buffer, "Launcher Puerta Salida: Error: %s\n", strerror(errno));
write(fileno(stdout), buffer, strlen(buffer));
}
srand(time(NULL));
int delay = (rand() % 2) + 1;
sprintf(buffer, "Launcher: Durmiendo durante %d\n", delay);
write(fileno(stdout), buffer, strlen(buffer));
sleep(delay);
}
sprintf(buffer, "Launcher: Terminado \n");
write(fileno(stdout), buffer, strlen(buffer));
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 4) {
strcpy (buffer, "Launcher: Error: Cantidad de parametros invalida\n Uso:\n ./launcher [CANT PUERTAS] [CAPACIDAD MAXIMA] [CANT PERSONAS]\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int cantPuertas = 0;
sscanf(argv[1] , "%d", &cantPuertas);
int cantMaxima = 0;
sscanf(argv[2] , "%d", &cantMaxima);
int cantPersonas = 0;
sscanf(argv[3] , "%d", &cantPersonas);
sprintf(buffer, "Launcher: Puertas: %d Capacidad maxima: %d\n", cantPuertas, cantMaxima);
write(fileno(stdout), buffer, strlen(buffer));
// Creando semaforo de control de acceso a la memoria compartida
Semaphore semControl = Semaphore();
if (semControl.createSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1) != 0) {
sprintf(buffer, "Launcher Error: El semaforo de control de acceso ya existe\n");
write(fileno(stdout), buffer, strlen(buffer));
exit(-1);
}
semControl.initializeSemaphore(0, 1);
// Creando memoria compartida
InfoMuseoSharedMemory shMem = InfoMuseoSharedMemory();
if (shMem.createSharedMemory((char *)DIRECTORY, ID_SHMEM) != 0) {
sprintf(buffer, "Launcher Error: La memoria compartida ya existe\n");
write(fileno(stdout), buffer, strlen(buffer));
exit(-1);
}
// Obteniendo la cola de mensajes de entrada
EntradaMessageQueue entradaMessageQueue = EntradaMessageQueue();
if (entradaMessageQueue.create((char*)DIRECTORY, ID_COLA_ENTRADA) != 0) {
sprintf (buffer, "Launcher Error: Cola de entrada ya existe\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Creando la cola de mensajes de respuesta
RespuestaMessageQueue respuestaMessageQueue = RespuestaMessageQueue();
if (respuestaMessageQueue.create((char*)DIRECTORY, ID_COLA_RESPUESTA) != 0) {
sprintf (buffer, "Launcher Error: Cola de respuesta ya existe\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Creando la cola de mensajes de salida
SalidaMessageQueue salidaMessageQueue = SalidaMessageQueue();
if (salidaMessageQueue.create((char*)DIRECTORY, ID_COLA_SALIDA) != 0) {
sprintf (buffer, "Launcher Error: Cola de salida ya existe\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Creando semaforo de bloqueo de puertas
Semaphore semPuertas = Semaphore();
if (semPuertas.createSemaphore((char *)DIRECTORY, ID_SEMPUERTAS, cantPuertas) != 0) {
sprintf (buffer, "Launche Error: Semaforos de bloqueo de puertas ya existen\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
for (int i = 0; i < cantPuertas; ++i) {
semControl.initializeSemaphore(i, 1);
}
InfoMuseo initialInfo;
initialInfo.abierto = true;
initialInfo.cantidad = 0;
initialInfo.cantidadMaxima = cantMaxima;
for (int i = 0; i < cantPuertas; ++i) {
initialInfo.puertasBloqueadas[i] = false;
}
semControl.wait(0);
{
shMem.writeInfo(&initialInfo);
}
semControl.signal(0);
static char cantidadPuertas[TAM_BUFFER];
sprintf(cantidadPuertas,"%d",cantPuertas);
// Creando puertas entrada
for (int i = 1; i <= cantPuertas; i++) {
pid_t pid = fork();
if (pid == 0) {
static char nroPuerta[TAM_BUFFER];
sprintf(nroPuerta,"%d",i);
execlp("./puertaEntrada", "puertaEntrada", nroPuerta, cantidadPuertas, (char *) 0);
sprintf(buffer, "Launcher Puerta Entrada: Error: %s\n", strerror(errno));
write(fileno(stdout), buffer, strlen(buffer));
}
}
// Creando puertas salida
for (int i = 1; i <= cantPuertas; i++) {
pid_t pid = fork();
if (pid == 0) {
static char nroPuerta[TAM_BUFFER];
sprintf(nroPuerta,"%d",i);
execlp("./puertaSalida", "puertaSalida", nroPuerta, cantidadPuertas, (char *) 0);
sprintf(buffer, "Launcher Puerta Salida: Error: %s\n", strerror(errno));
write(fileno(stdout), buffer, strlen(buffer));
}
}
// Creando personas
for (int i = 1; i <= cantPersonas; i++) {
pid_t pid = fork();
if (pid == 0) {
static char nroPersona[TAM_BUFFER];
sprintf(nroPersona,"%d",i);
execlp("./persona", "persona", nroPersona, cantidadPuertas, (char *) 0);
sprintf(buffer, "Launcher: Persona Error: %s\n", strerror(errno));
write(fileno(stdout), buffer, strlen(buffer));
}
srand(time(NULL));
int delay = (rand() % 10) + 1;
sprintf(buffer, "Launcher: Durmiendo durante %d\n", delay);
write(fileno(stdout), buffer, strlen(buffer));
sleep(delay);
}
sprintf(buffer, "Launcher: Terminado \n");
write(fileno(stdout), buffer, strlen(buffer));
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 2) {
strcpy (buffer, "Launcher: Error: Cantidad de parametros invalida\n Uso:\n ./launcher [CANT BOTELLAS]\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int cantBotellas = 0;
sscanf(argv[1] , "%d", &cantBotellas);
sprintf(buffer, "Launcher: Cantidad botellas: %d \n", cantBotellas);
write(fileno(stdout), buffer, strlen(buffer));
Semaphore semEmbotelladora = Semaphore();
Semaphore semEtiquetadora = Semaphore();
Semaphore semTapadora = Semaphore();
Semaphore semAlmacenadora = Semaphore();
try {
semEmbotelladora.createSemaphore((char *)DIRECTORY, ID_SEM_EMBOTELLADORA, 1);
semEmbotelladora.initializeSemaphore(0, 0);
semEtiquetadora.createSemaphore((char *)DIRECTORY, ID_SEM_ETIQUETADORA, 1);
semEtiquetadora.initializeSemaphore(0, 0);
semTapadora.createSemaphore((char *)DIRECTORY, ID_SEM_TAPADORA, 1);
semTapadora.initializeSemaphore(0, 0);
semAlmacenadora.createSemaphore((char *)DIRECTORY, ID_SEM_ALMACENADORA, 1);
semAlmacenadora.initializeSemaphore(0, 0);
}
catch (IPCException &ex) {
sprintf (buffer, "Launcher Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
static char cantidadBotellas[TAM_BUFFER];
sprintf(cantidadBotellas,"%d",cantBotellas);
// Creando Embotelladora
pid_t pid = fork();
if (pid == 0) {
execlp("./embotelladora", "embotelladora", cantidadBotellas,(char *) 0);
sprintf(buffer, "Launcher : Error: %s\n", strerror(errno));
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
// Creando Etiquetadora
pid = fork();
if (pid == 0) {
execlp("./etiquetadora", "etiquetadora", cantidadBotellas,(char *) 0);
sprintf(buffer, "Launcher : Error: %s\n", strerror(errno));
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
// Creando Tapadora
pid = fork();
if (pid == 0) {
execlp("./tapadora", "tapadora", cantidadBotellas,(char *) 0);
sprintf(buffer, "Launcher : Error: %s\n", strerror(errno));
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
// Creando Almacenadora
pid = fork();
if (pid == 0) {
execlp("./almacenadora", "almacenadora", cantidadBotellas,(char *) 0);
sprintf(buffer, "Launcher : Error: %s\n", strerror(errno));
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
sprintf(buffer, "Launcher: Terminado \n");
write(fileno(stdout), buffer, strlen(buffer));
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 1) {
strcpy (buffer, "Launcher: Error: Cantidad de parametros invalida.\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
sprintf(buffer, "Launcher: Iniciando\n");
write(fileno(stdout), buffer, strlen(buffer));
Semaphore semControl = Semaphore();
Semaphore semProductores = Semaphore();
Semaphore semAnalizadores = Semaphore();
MuestrasSharedMemory shMem = MuestrasSharedMemory();
try {
// Creando semaforo de control de acceso a la memoria compartida
semControl.createSemaphore((char *)DIRECTORY, ID_SEM_CONTROL, 1);
semControl.initializeSemaphore(0, 1);
// Creando semaforo de bloqueo de los productores
semProductores.createSemaphore((char *)DIRECTORY, ID_SEM_PRODUCTORES, CANT_MUESTRAS);
for (int i = 0; i < CANT_MUESTRAS; ++i) {
semProductores.initializeSemaphore(i, 1);
}
// Creando semaforo de bloqueo de los analizadores
semAnalizadores.createSemaphore((char *)DIRECTORY, ID_SEM_ANALIZADORES, CANT_ANALIZADORES);
for (int i = 0; i < CANT_ANALIZADORES; ++i) {
semAnalizadores.initializeSemaphore(i, 1);
}
// Creando memoria compartida
shMem.createSharedMemory((char *)DIRECTORY, ID_SHMEM_MUESTRAS);
Muestras estado;
for (int i = 0; i < CANT_MUESTRAS; ++i) {
estado.muestra[i] = VACIO;
estado.productorBloqueado[i] = false;
}
for (int i = 0; i < CANT_ANALIZADORES; ++i) {
// Indica que no esta bloqueado
estado.analizadorBloqueado[i] = CANT_MUESTRAS;
}
for (int j = 0; j < CANT_ANALIZADORES; ++j) {
for (int i = 0; i < CANT_MUESTRAS; ++i) {
// Inicialmente marco como que todas las muestras fueron analizadas por todos los analizadores
estado.estadoMuestras[j][i] = true;
}
}
semControl.wait(0);
{
shMem.writeInfo(&estado);
}
semControl.signal(0);
}
catch (IPCException &ex) {
sprintf (buffer, "Launcher Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Creando Productores
for (int i = 0; i < CANT_MUESTRAS; ++i) {
static char nroProductor[TAM_BUFFER];
sprintf(nroProductor,"%d",i);
pid_t pid = fork();
if (pid == 0) {
execlp("./productor", "productor", nroProductor, (char *) 0);
sprintf(buffer, "Launcher Productor: Error: %s\n", strerror(errno));
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
}
// Creando Analizadores
for (int i = 0; i < CANT_ANALIZADORES; ++i) {
static char nroAnalizador[TAM_BUFFER];
sprintf(nroAnalizador,"%d",i);
pid_t pid = fork();
if (pid == 0) {
execlp("./analizador", "analizador", nroAnalizador, (char *) 0);
sprintf(buffer, "Launcher Analizador: Error: %s\n", strerror(errno));
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
}
sprintf(buffer, "Launcher: Terminado \n");
write(fileno(stdout), buffer, strlen(buffer));
return 0;
}
