BoundedBuffer::BoundedBuffer(){
buf = new Item[0];
count = 0;
usedSlots = Semaphore(0);
openSlots = Semaphore(0);
itemsTakenOut = 0;
itemsPutIn = 0;
}
BoundedBuffer::BoundedBuffer(int _size){
buf = new Item[_size];
count = 0;
usedSlots = Semaphore(0);
openSlots = Semaphore(_size);
itemsTakenOut = 0;
itemsPutIn=0;
}
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;
}
Buffer::Buffer (int cantidadProductores) {
// Obtengo semaforo de control de acceso a la memoria compartida
semControl = Semaphore();
semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1);
// Obtengo semaforos de control de los procesos
semProductores = Semaphore();
semProductores.getSemaphore((char *)DIRECTORY, ID_SEMPRODUCTORES, cantidadProductores);
// Obtengo la memoria compartida
shMem = CountingSharedMemory();
shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM);
this->cantidadProductores = cantidadProductores;
}
int main(int argc, char **argv)
{
Semaphore semControl = Semaphore();
semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1);
semControl.destroy();
// Obteniendo memoria compartida
TicketsInfoSharedMemory shMem = TicketsInfoSharedMemory();
shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM);
shMem.destroy();
// Obteniendo colas de mensajes
GetVendedorMessageQueue getVendedorQueue1 = GetVendedorMessageQueue();
getVendedorQueue1.getMessageQueue((char*)DIRECTORY, ID_GET_VENDEDOR_1);
getVendedorQueue1.destroy();
ComprarMessageQueue comprarQueue1 = ComprarMessageQueue();
comprarQueue1.getMessageQueue((char*)DIRECTORY, ID_COMPRAR_1);
comprarQueue1.destroy();
VenderMessageQueue venderQueue1 = VenderMessageQueue();
venderQueue1.getMessageQueue((char*)DIRECTORY, ID_VENDER_1);
venderQueue1.destroy();
GetVendedorMessageQueue getVendedorQueue2 = GetVendedorMessageQueue();
getVendedorQueue2.getMessageQueue((char*)DIRECTORY, ID_GET_VENDEDOR_2);
getVendedorQueue2.destroy();
ComprarMessageQueue comprarQueue2 = ComprarMessageQueue();
comprarQueue2.getMessageQueue((char*)DIRECTORY, ID_COMPRAR_2);
comprarQueue2.destroy();
VenderMessageQueue venderQueue2 = VenderMessageQueue();
venderQueue2.getMessageQueue((char*)DIRECTORY, ID_VENDER_2);
venderQueue2.destroy();
// Obteniendo memoria compartida de numerador
NumeradorSharedMemory shMemNum = NumeradorSharedMemory();
shMemNum.getSharedMemory((char *)DIRECTORY_NUM, ID_SHMEM_NUMERADOR);
shMemNum.destroy();
Semaphore semControlNum = Semaphore();
semControlNum.getSemaphore((char *)DIRECTORY_NUM, ID_SEMCONTROL_NUMERADOR, 1);
semControlNum.destroy();
return 0;
}
ControladorAdministrador::ControladorAdministrador () {
// Creando semaforo de control de acceso a la memoria compartida
semControl = Semaphore();
semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1);
// Obteniendo memoria compartida
shMem = InfoMuseoSharedMemory();
shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM);
}
void CintaTransportadora6::iniciarCinta(int idClave) {
semaforoAcceso = Semaphore();
semaforoAcceso.getSemaphore(DIRECTORY, idClave, 1);
cinta = CintaTransportadoraSharedMemory();
cinta.getSharedMemory(DIRECTORY, idClave);
}
BoundedBuffer::BoundedBuffer(int n){
first = 0;
after_last = 0;
count = 0;
MAX = n;
sema = Semaphore(1);
for(int i = 0; i < MAX; i++) {
space.push_back("!"); // "!" placeholder content; should never be seen
}
}
PIMPL(WorkerThread*x) : owner(x), ID(0)
, keeprunning(true), isrunning(false)
, m_todo(Mutex()), m_done(Mutex())
, s_newdata(Semaphore())
, processingID(WorkerThread::INVALID)
#ifndef HAVE_PTW32_HANDLE_T
, p_thread(0)
#endif
{
pthread_mutex_init(&p_runmutex, 0);
pthread_cond_init (&p_runcond , 0);
}
int main(int argc, char **argv)
{
// Obtengo los semaforos que controlan el avance de productores y analizadores
Semaphore semProductores = Semaphore();
semProductores.getSemaphore((char *)DIRECTORY,ID_SEMPRODUCTORES, CANT_PRODUCTORES);
semProductores.destroy();
Semaphore semAnalizadores = Semaphore();
semAnalizadores.getSemaphore((char *)DIRECTORY,ID_SEMANALIZADORES, CANT_ANALIZADORES);
semAnalizadores.destroy();
// Obtengo el semaforo que controla el acceso a la memoria compartida
Semaphore semControl = Semaphore();
semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1);
semControl.destroy();
// Obtengo la memoria compartida
SamplesTableSharedMemory table = SamplesTableSharedMemory();
table.getSharedMemory((char *)DIRECTORY, ID_SHMEM);
table.destroy();
return 0;
}
template<typename T> TSharedMemory<T>::TSharedMemory(const QString& Key)
: m_pMemory(new QSharedMemory(Key))
{
/* Может показаться, что для блокировки доступа достаточно использовать
встроенный блокировщик класса QSharedMemory. Однако, это не так.
Встроенный блокировщик (семафор) не рекурсивный и используется внутри
функции QSharedMemory::create. Это приводит к тому, что после
разблокировки семафора функцией create даже при предшествующей её вызову
блокировке семафора блокировка снимается и другой поток или приложение,
использующее данный класс, способно начать работу с выделенной памятью,
в то время как конструктор память ещё не инициализировал. Чтобы избежать
такой ситуации вводится системный семафор (общий для всех приложений),
который защищает весь код конструктора. Любой другой поток будет
блокирован до тех пор, пока конструктор не закончит работу, т.е. выделит
и инициализирует память.
*/
QSystemSemaphore Semaphore(QLatin1String("TShMemSysSem-") + Key, 1);
Semaphore.acquire();
bool Created = m_pMemory->create(sizeof(T));
if (Created || m_pMemory->error() == QSharedMemory::AlreadyExists)
{
if (m_pMemory->isAttached() || m_pMemory->attach())
{
void* p = m_pMemory->data();
if (p != NULL) {
if (Created) {
new(p) T();
}
}
else {
qWarning("TSharedMemory. Shared memory pointer is NULL.");
}
}
else {
qWarning("TSharedMemory. Error attaching to shared memory: %s",
qPrintable(m_pMemory->errorString()));
}
}
else {
qWarning("TSharedMemory. Error allocating shared memory: %s",
qPrintable(m_pMemory->errorString()));
}
Semaphore.release();
}
int main(int argc, char** argv) {
char buffer[TAM_BUFFER];
try {
/* Obtengo la cola de comunicacion con el robot 5 con los dos procesos del controlador */
ComunicacionRobot5MessageQueue colaComunicacionRobot5 = ComunicacionRobot5MessageQueue();
colaComunicacionRobot5.getMessageQueue(DIRECTORY,ID_COLA_API_ROBOT_5);
colaComunicacionRobot5.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo la cola de pedidos del robot 5 */
PedidosProduccionMessageQueue colaPedidos = PedidosProduccionMessageQueue();
colaPedidos.getMessageQueue(DIRECTORY,ID_COLA_PEDIDOS_PRODUCCION);
colaPedidos.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
/*
* ROBOT 5 - AGV
*/
try {
/* Obtengo los buffer para depositar los canastos */
BufferCanastoSharedMemory bufferCanasto[3];
bufferCanasto[0].getSharedMemory(DIRECTORY, ID_BUFFER_CANASTOS_0);
bufferCanasto[0].destroy();
bufferCanasto[1].getSharedMemory(DIRECTORY, ID_BUFFER_CANASTOS_1);
bufferCanasto[1].destroy();
bufferCanasto[2].getSharedMemory(DIRECTORY, ID_BUFFER_CANASTOS_2);
bufferCanasto[2].destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo los semaforos de acceso a los buffer de los canastos */
Semaphore semaforoAccesoBufferAgv;
semaforoAccesoBufferAgv.getSemaphore(DIRECTORY, ID_SEM_ACCESO_BUFFER_AGV, 3);
semaforoAccesoBufferAgv.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo los semaforos de bloqueo de los Agv */
Semaphore semaforoBloqueoAgv;
semaforoBloqueoAgv.getSemaphore(DIRECTORY, ID_SEM_BLOQUEO_AGV, 3);
semaforoBloqueoAgv.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo la cola de pedidos de los AGV */
PedidosAgvMessageQueue colaPedidosAgv;
colaPedidosAgv.getMessageQueue(DIRECTORY,ID_COLA_PEDIDOS_AGV_5);
colaPedidosAgv.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
/*
* Robot 5 - Cinta
*/
try {
/* Obtengo las memorias compartidas y los semaforos de las cintas transportadoras */
Semaphore semCinta0 = Semaphore();
semCinta0.getSemaphore(DIRECTORY, ID_CINTA_6_0, 1);
semCinta0.destroy();
CintaTransportadoraSharedMemory memCinta0 = CintaTransportadoraSharedMemory();
memCinta0.getSharedMemory(DIRECTORY, ID_CINTA_6_0);
memCinta0.destroy();
Semaphore semCinta1 = Semaphore();
semCinta1.getSemaphore(DIRECTORY, ID_CINTA_6_1, 1);
semCinta1.destroy();
CintaTransportadoraSharedMemory memCinta1 = CintaTransportadoraSharedMemory();
memCinta1.getSharedMemory(DIRECTORY, ID_CINTA_6_1);
memCinta1.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo el semaforo de bloqueo del robot 5 */
Semaphore semBloqueo5 = Semaphore();
semBloqueo5.getSemaphore(DIRECTORY, ID_SEM_BLOQUEO_ROBOT_5, 1);
semBloqueo5.destroy();
/* Obtengo la memoria de estado del robot 5 y el semaforo de acceso */
EstadoRobot5SharedMemory estadoRobot5 = EstadoRobot5SharedMemory();
estadoRobot5.getSharedMemory(DIRECTORY, ID_MEM_ESTADO_ROBOT_5);
estadoRobot5.destroy();
Semaphore semaforoAccesoEstadoRobot5 = Semaphore();
semaforoAccesoEstadoRobot5.getSemaphore(DIRECTORY, ID_SEM_ACCESO_ESTADO_ROBOT_5, 1);
semaforoAccesoEstadoRobot5.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
try {
/* Obtengo la memoria de estado de los robot 11 y los semaforos de acceso */
EstadoRobot11SharedMemory estadoRobot11[2];
estadoRobot11[0].getSharedMemory(DIRECTORY, ID_MEM_ESTADO_ROBOT_11_0);
estadoRobot11[0].destroy();
estadoRobot11[1].getSharedMemory(DIRECTORY, ID_MEM_ESTADO_ROBOT_11_1);
estadoRobot11[1].destroy();
Semaphore semaforoAccesoEstadoRobot11 = Semaphore();
semaforoAccesoEstadoRobot11.getSemaphore(DIRECTORY, ID_SEM_ACCESO_ESTADO_ROBOT_11, 2);
semaforoAccesoEstadoRobot11.destroy();
/* Obtengo los semaforos de bloqueo del robot 11 */
Semaphore semaforoBloqueoRobot11 = Semaphore();
semaforoBloqueoRobot11.getSemaphore(DIRECTORY, ID_SEM_BLOQUEO_ROBOT_11, 2);
semaforoBloqueoRobot11.destroy();
}
catch (IPCException const& ex) {
sprintf(buffer, "Terminator Robot 5:Error: %s\n", ex.what());
write(fileno(stderr), buffer, strlen(buffer));
exit(-1);
}
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 != 2) {
strcpy (buffer, "Error Puerta Entrada: Cantidad de parametros invalida\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
srand (time(NULL));
int totalPuerta = 0;
int nroPuerta = 0;
sscanf(argv[1] , "%d", &nroPuerta);
sprintf(buffer, "Puerta Entrada: %d Iniciando\n", nroPuerta);
write(fileno(stdout), buffer, strlen(buffer));
// Creando semaforo de control de acceso a la memoria compartida
Semaphore semControl = Semaphore();
if (semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener el semaforo de control\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo memoria compartida
InfoMuseoSharedMemory shMem = InfoMuseoSharedMemory();
if (shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener la memoria\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
bool deboSeguir = true;
while (deboSeguir) {
int dormir = rand() % 5 + 1;
sprintf (buffer, "Puerta Entrada: %d Durmiendo por %d segundos\n", nroPuerta, dormir);
write (fileno(stdout),buffer, strlen(buffer));
usleep(dormir*1000*1000);
totalPuerta++;
sprintf (buffer, "Puerta Entrada: %d Llego la persona %d\n", nroPuerta, totalPuerta);
write (fileno(stdout),buffer, strlen(buffer));
int semaphoreOperation = semControl.wait(0);
if (semaphoreOperation == -1) exit(-1);
{
InfoMuseo *info = shMem.readInfo();
if (! (*info).abierto) {
sprintf (buffer, "Puerta Entrada: %d El museo esta CERRADO, la persona %d debe irse\n", nroPuerta,totalPuerta);
write (fileno(stdout),buffer, strlen(buffer));
}
else {
if ((*info).cantidad == (*info).cantidadMaxima) {
sprintf (buffer, "Puerta Entrada: %d El museo esta LLENO, la persona %d debe irse\n", nroPuerta,totalPuerta);
write (fileno(stdout),buffer, strlen(buffer));
}
else {
sprintf (buffer, "Puerta Entrada: %d La persona %d ingresa al museo\n", nroPuerta,totalPuerta);
write (fileno(stdout),buffer, strlen(buffer));
(*info).cantidad++;
(*info).total++;
shMem.writeInfo(info);
}
}
}
semControl.signal(0);
if (semaphoreOperation == -1) exit(-1);
}
return 0;
}
int main(int argc, char **argv)
{
try {
// Obteniendo semaforo de control de acceso a la memoria compartida Sala
Semaphore semControlSala = Semaphore();
semControlSala.getSemaphore((char *)DIRECTORY, ID_SEM_CONTROL_SALA, 1);
semControlSala.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
try{
// Obteniendo semaforo de bloqueo de la puerta
Semaphore semPuerta = Semaphore();
semPuerta.getSemaphore((char *)DIRECTORY, ID_SEM_PUERTA, 1);
semPuerta.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
try{
// Obteniendo semaforo de bloqueo de buses
Semaphore semBuses = Semaphore();
semBuses.getSemaphore((char *)DIRECTORY, ID_SEM_BUSES, 1);
semBuses.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
try{
// Obteniendo la cola de mensajes de intercambio
IntercambioMessageQueue intercambioMessageQueue = IntercambioMessageQueue();
intercambioMessageQueue.getMessageQueue((char*)DIRECTORY, ID_COLA_PERSONAS);
intercambioMessageQueue.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
try{
// Obteniendo memoria compartida Sala
InfoSalaSharedMemory shMemSala = InfoSalaSharedMemory();
shMemSala.getSharedMemory((char *)DIRECTORY, ID_SHMEM_SALA);
shMemSala.destroy();
}
catch (IPCException &ex) {
char buffer[TAM_BUFFER];
sprintf (buffer, "Terminator Error: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
}
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 3) {
strcpy (buffer, "Error Puerta Entrada: Cantidad de parametros invalida\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int nroPuerta = 0;
sscanf(argv[1] , "%d", &nroPuerta);
int totalPuertas = 0;
sscanf(argv[2] , "%d", &totalPuertas);
sprintf(buffer, "Puerta Entrada: %d Iniciando\n", nroPuerta);
write(fileno(stdout), buffer, strlen(buffer));
// Obteniendo semaforo de control de acceso a la memoria compartida
Semaphore semControl = Semaphore();
if (semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener el semafoto de control\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo semaforo de control de acceso a las puertas
Semaphore semPuertas = Semaphore();
if (semPuertas.getSemaphore((char *)DIRECTORY, ID_SEMPUERTAS, totalPuertas) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener el semafoto de las puertas\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo memoria compartida
InfoMuseoSharedMemory shMem = InfoMuseoSharedMemory();
if (shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener la memoria\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo la cola de mensajes de entrada
EntradaMessageQueue entradaMessageQueue = EntradaMessageQueue();
if (entradaMessageQueue.getMessageQueue((char*)DIRECTORY, ID_COLA_ENTRADA) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener la cola de entrada\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
// Obteniendo la cola de mensajes de respuesta
RespuestaMessageQueue respuestaMessageQueue = RespuestaMessageQueue();
if (respuestaMessageQueue.getMessageQueue((char*)DIRECTORY, ID_COLA_RESPUESTA) != 0) {
sprintf (buffer, "Puerta Entrada: %d Fallo al obtener la cola de respuesta\n", nroPuerta);
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
bool deboSeguir = true;
while (deboSeguir) {
MensajeEntrada entrada;
entradaMessageQueue.recibirMensajeEntrada(nroPuerta, &entrada);
sprintf (buffer, "Puerta Entrada: %d Recibio a la persona %d\n", nroPuerta, entrada.idPersona);
write (fileno(stdout),buffer, strlen(buffer));
int semaphoreOperation = semControl.wait(0);
if (semaphoreOperation == -1) exit(-1);
{
InfoMuseo *info = shMem.readInfo();
if (! (*info).abierto) {
sprintf (buffer, "Puerta Entrada: %d Museo cerrado, la persona %d debe irse\n", nroPuerta, entrada.idPersona);
write (fileno(stdout),buffer, strlen(buffer));
MensajeRespuesta respuesta;
respuesta.mtype = entrada.idPersona;
respuesta.resultado = false;
respuestaMessageQueue.enviarMensajeRespuesta(respuesta);
deboSeguir = false;
}
else {
sprintf (buffer, "Puerta Entrada: %d Museo abierto, la persona %d puede entrar\n", nroPuerta, entrada.idPersona);
write (fileno(stdout),buffer, strlen(buffer));
bool capacidadDisponible = !((*info).cantidad == (*info).cantidadMaxima);
while ( !capacidadDisponible ) {
(*info).puertasBloqueadas[nroPuerta - 1] = true;
shMem.writeInfo(info);
semaphoreOperation = semControl.signal(0);
if (semaphoreOperation == -1) exit(-1);
semaphoreOperation = semPuertas.wait(nroPuerta-1);
if (semaphoreOperation == -1) exit(-1);
semaphoreOperation = semControl.wait(0);
if (semaphoreOperation == -1) exit(-1);
{
capacidadDisponible = !((*info).cantidad == (*info).cantidadMaxima);
}
}
(*info).puertasBloqueadas[nroPuerta - 1] = false;
sprintf (buffer, "Puerta Entrada: %d Museo abierto, capacidad disponible\n", nroPuerta);
write (fileno(stdout),buffer, strlen(buffer));
MensajeRespuesta respuesta;
respuesta.mtype = entrada.idPersona;
respuesta.resultado = true;
respuestaMessageQueue.enviarMensajeRespuesta(respuesta);
(*info).cantidad++;
shMem.writeInfo(info);
}
}
semaphoreOperation = semControl.signal(0);
if (semaphoreOperation == -1) exit(-1);
}
sprintf (buffer, "Puerta Entrada: %d Terminando\n", nroPuerta);
write (fileno(stdout),buffer, strlen(buffer));
return 0;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 2) {
strcpy (buffer, "Productor: Error: Cantidad de parametros invalida\n Uso:\n ./productor [NRO PRODUCTOR]\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
int nroProductor = 0;
sscanf(argv[1] , "%d", &nroProductor);
sprintf(buffer, "Productor %d: Iniciando\n", nroProductor);
write(fileno(stdout), buffer, strlen(buffer));
Semaphore semControl = Semaphore();
Semaphore semProductores = Semaphore();
Semaphore semAnalizadores = Semaphore();
MuestrasSharedMemory shMem = MuestrasSharedMemory();
try {
// Obteniendo semaforo de control de acceso a la memoria compartida
semControl.getSemaphore((char *)DIRECTORY, ID_SEM_CONTROL, 1);
// Obteniendo semaforo de bloqueo de los procesos
semProductores.getSemaphore((char *)DIRECTORY, ID_SEM_PRODUCTORES, CANT_MUESTRAS);
// Obteniendo semaforo de bloqueo de los procesos
semAnalizadores.getSemaphore((char *)DIRECTORY, ID_SEM_ANALIZADORES, CANT_ANALIZADORES);
// Obteniendo memoria compartida
shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM_MUESTRAS);
}
catch (IPCException &ex) {
sprintf (buffer, "Productor %d: Error Init: %s\n", nroProductor, ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
bool deboSeguir = true;
while (deboSeguir) {
try {
semControl.wait();
Muestras *estado = shMem.readInfo();
// Verifico si la muestra ya fue analizada por todos los analizadores
bool cambiar = puedoCambiar(estado, nroProductor);
while (! cambiar) {
sprintf(buffer, "Productor %d: La muestra todavia no fue analizada por completo.\n",nroProductor);
write(fileno(stdout), buffer, strlen(buffer));
// La muestra no fue analizada por completo, me bloqueo esperando que todos los analizadores terminen
(*estado).productorBloqueado[nroProductor] = true;
shMem.writeInfo(estado);
// Libero la memoria compartida
semControl.signal();
// Me bloqueo en mi semaforo
semProductores.wait(nroProductor);
// Obtengo la memoria compartida y vuelvo a verificar si debo producir
semControl.wait();
estado = shMem.readInfo();
cambiar = puedoCambiar(estado, nroProductor);
}
// Todos los analizadores analizaron la muestra, puedo colocar una nueva muestra
sprintf(buffer, "Productor %d: La muestra ya fue analizada por completo, procedo a cambiarla.\n",nroProductor);
write(fileno(stdout), buffer, strlen(buffer));
// Libero la memoria compartida mientras busco una nueva muestra
semControl.signal();
// Busco una nueva muestra
srand(time(NULL));
int delay = (rand() % 3) + 1;
sprintf(buffer, "Productor %d: Buscando una nueva muestra durante %d\n", nroProductor, delay);
write(fileno(stdout), buffer, strlen(buffer));
sleep(delay);
// Una vez depositada la nueva muestra, desbloqueo a los analizadores necesarios
semControl.wait();
estado = shMem.readInfo();
// Indico que hay una nueva muestra para analizar y
// verifico si hay algun analizador bloqueado en mi muestra y lo libero
for (int j = 0; j < CANT_ANALIZADORES; ++j) {
(*estado).estadoMuestras[j][nroProductor] = false;
if ((*estado).analizadorBloqueado[j] == nroProductor) {
sprintf(buffer, "Productor %d: Libero al analizador %d\n", nroProductor, j);
write(fileno(stdout), buffer, strlen(buffer));
// Libero al analizador que esta esperando la muestra
(*estado).analizadorBloqueado[j] = CANT_MUESTRAS;
semAnalizadores.signal(j);
}
}
shMem.writeInfo(estado);
semControl.signal();
}
catch (IPCException &ex) {
sprintf (buffer, "Productor %d: Error: %s\n", nroProductor, ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
}
sprintf(buffer, "Productor %d: Terminado \n",nroProductor);
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 != 2) {
strcpy (buffer, "Canal Memoria Compartida: Error - Cantidad de parametros invalida\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int socketComunicacion = 0;
sscanf(argv[1] , "%d", &socketComunicacion);
sprintf (buffer,"Canal Memoria Compartida: Iniciando\n");
write(fileno(stdout), buffer, strlen(buffer));
// Obteniendo semaforo de control de acceso a la memoria compartida
semControl = Semaphore();
semControl.getSemaphore((char *)DIRECTORY, ID_SEMCONTROL, 1);
// Obteniendo memoria compartida
shMem = TicketsInfoSharedMemory();
shMem.getSharedMemory((char *)DIRECTORY, ID_SHMEM);
char buffer[TAM_BUFFER];
PaqueteTicketsInfo paqueteIntercambio;
bool deboSeguir;
do {
if (recibir(socketComunicacion, buffer, TAM_BUFFER) != TAM_BUFFER) {
sprintf(buffer, "Canal Memoria Compartida - Error al recibir un pedido de memoria. ERROR: %d.\n", errno);
write (fileno(stderr),buffer, strlen(buffer));
close(socketComunicacion);
exit(-1);
}
memcpy(&paqueteIntercambio, buffer, sizeof(PaqueteTicketsInfo));
deboSeguir = paqueteIntercambio.deboSeguir;
if (deboSeguir) {
// Lllego un pedido de memoria compartida
senControl.wait();
TicketsInfo *info = shMem.readInfo();
/* Envio la memoria compartida */
memcpy(&paqueteIntercambio.ticketsInfo, info, sizeof(TicketsInfo));
memcpy(buffer, &paqueteIntercambio, sizeof(PaqueteTicketsInfo));
if (enviar(socketComunicacion, buffer, TAM_BUFFER) != TAM_BUFFER) {
sprintf(buffer, "Canal Memoria Compartida - Error al enviar la memoria\n");
write (fileno(stderr),buffer, strlen(buffer));
senControl.signal();
close(socketComunicacion);
exit(-1);
}
/* Recibo la memoria compartida actualizada */
if (recibir(socketComunicacion, buffer, TAM_BUFFER) != TAM_BUFFER) {
sprintf(buffer, "Canal Memoria Compartida - Error al recibir una actualización de memoria. ERROR: %d.\n", errno);
write (fileno(stderr),buffer, strlen(buffer));
senControl.signal();
close(socketComunicacion);
exit(-1);
}
memcpy(&paqueteIntercambio, buffer, sizeof(PaqueteTicketsInfo));
shMem.writeInfo(paqueteIntercambio.ticketsInfo);
deboSeguir = paqueteIntercambio.deboSeguir;
senControl.signal();
}
} while (deboSeguir);
close(socketEntrada);
}
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;
}
int main(int argc, char **argv)
{
char buffer[TAM_BUFFER];
if (argc != 2) {
strcpy (buffer, "Error Almacenadora: Cantidad de parametros invalida.\n");
write (fileno(stderr),buffer, strlen(buffer));
exit(1);
}
int cantBotellas = 0;
sscanf(argv[1] , "%d", &cantBotellas);
sprintf(buffer, "Almacenadora: Iniciando\n");
write(fileno(stdout), buffer, strlen(buffer));
Semaphore semAlmacenadora = Semaphore();
Semaphore semEmbotelladora = Semaphore();
try {
semAlmacenadora.getSemaphore((char *)DIRECTORY, ID_SEM_ALMACENADORA, 1);
semEmbotelladora.getSemaphore((char *)DIRECTORY, ID_SEM_EMBOTELLADORA, 1);
}
catch (IPCException &ex) {
sprintf (buffer, "Almacenadora: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
bool deboSeguir = (cantBotellas > 0);
while (deboSeguir) {
try {
srand(time(NULL));
int delay = (rand() % 3) + 1;
sprintf(buffer, "Almacenadora: Depositando botella vacia durante %d segundos\n", delay);
write(fileno(stdout), buffer, strlen(buffer));
sleep(delay);
semEmbotelladora.signal();
semAlmacenadora.wait();
delay = (rand() % 3) + 1;
sprintf(buffer, "Almacenadora: Depositando botella en caja durante %d segundos\n", delay);
write(fileno(stdout), buffer, strlen(buffer));
sleep(delay);
cantBotellas--;
deboSeguir = (cantBotellas > 0);
}
catch (IPCException &ex) {
sprintf (buffer, "Almacenadora: %s\n", ex.getDescription());
write (fileno(stderr),buffer, strlen(buffer));
exit(-1);
}
}
sprintf (buffer, "Almacenadora: Terminando\n");
write (fileno(stdout),buffer, strlen(buffer));
return 0;
}
