/*
* C++ class to encapsulate Unix semaphore intrinsic structures and system calls
* Author: Programacion Concurrente (Francisco Arroyo)
* Version: 2020/Ago/04
*
* En esta nueva versión vamos a construir un arreglo de semáforos,
* el tamaño es indicado por el constructor (cantidad)
* Las operaciones Wait y Signal reciben el parámetro sobre el cual se pretende
* realizar esa operación
* Además, vamos a agregar dos métodos nuevos para poder operar sobre dos
* semáforos simultáneamente y resolver el problema de los filósofos
*
*/
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <unistd.h>
#include "Semaphore.h"
Semaphore::Semaphore( int cantidad, int valorInicial ) {
int status;
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
} value;
status = semget( IPC_PRIVATE, cantidad, 0600 | IPC_CREAT | IPC_EXCL );
if ( -1 == status ) {
perror( "Semaphore::Semaphore(int, int) creator" );
exit( 23 );
}
this->semId = status;
this->nsems = cantidad;
this->creador = getpid();
value.val = valorInicial; // Each semaphore will be initialized to this value
for ( int i = 0; i < this->nsems; i++ ) {
status = semctl( this->semId, i, SETVAL, value );
if ( -1 == status ) {
perror( "Semaphore::Semaphore(int, int) initializer" );
exit( 23 );
}
}
}
Semaphore::~Semaphore() {
int resultado;
if ( this->creador == getpid() ) {
resultado = semctl( this->semId, IPC_RMID, 0 );
}
}
int Semaphore::Signal( int cual ) {
int status = -1;
struct sembuf S;
S.sem_num = cual;
S.sem_op = 1;
S.sem_flg = 0;
status = semop( this->semId, &S, 1 );
if ( -1 == status ) {
perror( "Semaphore::Signal" );
exit( 23 );
}
return status;
}
int Semaphore::Wait( int cual ) {
int status = -1;
struct sembuf P;
P.sem_num = cual;
P.sem_op = -1;
P.sem_flg = 0;
status = semop( this->semId, &P, 1 );
if ( -1 == status ) {
perror( "Semaphore::Wait" );
exit( 23 );
}
return status;
}
/*
* Do a Wait operation on two semaphores, will try to substract one to each semaphore
* This operation must be atomic, not allowed to block one semaphore
* and try to block the other
* The block operation must occur on both semaphores atomically
* It will try to get the lock on two semaphores from the group,
* especified by parameters
*
*/
void Semaphore::SP( int primero, int segundo ) {
int resultado;
struct sembuf P[ 2 ];
P[ 0 ].sem_num = primero;
P[ 0 ].sem_op = -1;
P[ 0 ].sem_flg = 0;
P[ 1 ].sem_num = segundo;
P[ 1 ].sem_op = -1;
P[ 1 ].sem_flg = 0;
// resultado = semop( ... );
}
/*
*
*/
void Semaphore::SV( int primero, int segundo ) {
}
/*
*
*/
void Semaphore::setInitialValue( int valorInicial ) {
int resultado;
union semun {
int val;
struct semid_ds *buf;
unsigned short *array;
struct seminfo *__buf;
} value;
value.val = valorInicial; // Each semaphore will be initialized to this value
for ( int i = 0; i < this->nsems; i++ ) {
resultado = semctl( semId, i, SETVAL, value );
if ( -1 == resultado ) {
perror( "Semaphore::Semaphore(int)" );
exit( 23 );
}
}
}
