2. Problema de Análisis y Diseño Orientado a Objetos (5 puntos - 30 minutos)

(1)

Calificación APELLIDOS

NOMBRE Nº Mat.

UNIVERSIDAD POLITÉCNICA DE MADRID

ESCUELA TÉCNICA SUPERIOR DE INGENIERÍA Y DISEÑO INDSUTRIAL

ASIGNATURA: SISTEMAS INFORMÁTICOS INDUSTRIALES

Departamento de Ingeniería Eléctrica, Electrónica, Automática y Física Aplicada

CURSO 4º GRUPO Julio 2017

2. Problema de Análisis y Diseño Orientado a Objetos (5 puntos - 30 minutos)

Dado el siguiente código, se pide.

1. Ingeniería inversa del código adjuntado (2 puntos).

2. Salida de la consola con la ejecución del programa (2 puntos).

3. Implementación de la clase TechoSolar en C++. Suponga que esta opción tiene un precio de 750 € (1

punto).

class AireAcondicionado : public OpcionesCoche {

Coche *base; public:

AireAcondicionado(Coche *b){base = b;} string getDescripcion(){

return base->getDescripcion() + ", Aire Acondicionado"; } double getPrecio(){ return 450 + base->getPrecio(); } ~AireAcondicionado(){cout << "~AireAcondicionado()\n"; } }; int main() {

Coche *modelo = new SeatLeon(); cout << "Modelo base "

<< modelo->getDescripcion()

<< " precio " << modelo->getPrecio() << " euros\n";

modelo = new Navegador(modelo); cout << modelo->getDescripcion()

<< " cuesta " << modelo->getPrecio() << " euros\n";

modelo = new AireAcondicionado(modelo); //modelo = new TechoSolar(modelo); cout << modelo->getDescripcion() << " cuesta " << modelo->getPrecio() << " euros\n"; delete modelo; return 0; } #include <string> #include <iostream> using namespace std; class Coche{ protected: string modelo; public:

Coche(){ modelo = "Sin definir";} virtual string getDescripcion(){ return modelo;

}

virtual double getPrecio() = 0;

virtual ~Coche(){ cout << "~Coche()\n";} };

class OpcionesCoche : public Coche{ public:

virtual string getDescripcion() = 0; virtual ~OpcionesCoche(){

cout<<"~OpcionesCoche()\n"; }

};

class SeatLeon : public Coche{ public:

SeatLeon(){ modelo = "SeatLeon";}

virtual double getPrecio(){return 12000;} ~SeatLeon(){ cout<<"~SeatLeon()\n";} };

class Navegador: public OpcionesCoche{ Coche *base;

public:

Navegador(Coche *b){base = b;} string getDescripcion(){

return base->getDescripcion() + ", Navegador"; } double getPrecio(){ return 300 + base->getPrecio(); } ~Navegador(){cout << "~Navegador()\n";} };

(2)

2. Modelo base Seat Leon precio 12000 euros

Seat Leon, Navegador cuesta 12300 euros

Seat Leon, Navegador, Aire Acondicionado cuesta 12750 euros

AireAcondicionado()

OpcionesCoche()

Coche()

3.

class TechoSolar : public OpcionesCoche { Coche *base; public: TechoSolar(Coche *b){ base = b; } string getDescripcion(){

return base->getDescripcion() + ", Techo Solar"; } double getPrecio(){ return 750 + base->getPrecio(); } ~TechoSolar(){ cout << "~TechoSolar()\n"; } };

(3)

NOMBRE Nº Mat.

3. Problema de Análisis y Diseño Orientado a Objetos (5 puntos - 30 minutos)

Se está programando un juego de realidad virtual. En dicho juego aparecen personajes virtuales que realizan

tareas cotidianas. Existe un personaje controlado por el jugador, y existe otro controlado por el programa que es

el cajero de una tienda, el cual gestiona una determinada caja. Se está desarrollando la funcionalidad que

permite a un jugador realizar un pago a un cajero. Para probar esta funcionalidad, la función main() invoca la

función Recibe() del jugador con 300 unidades de dinero, que incrementa su saldo. Cuando el main() le ordena a

un personaje (en este caso, el jugador) que pague 50 unidades, decrementa su saldo en dicha cantidad, que

recibe su interlocutor (en este caso, el cajero). El cajero, en lugar de quedárselo, debe ingresarlo en la caja, y

luego sacar su comisión de la misma, que es la que incrementa su saldo. Considérese que el saldo inicial de los

personajes es de 100 unidades de dinero y el de la caja 1000.

Se pide:

1. Diagrama de Clases de Diseño (DCD) que soporte el diagrama y requisitos anteriores. (2.5 puntos)

2. Código C++ de la aplicación completa, incluyendo el main() de prueba. (2.5 puntos)

(4)

#include <iostream> using namespace std; class Caja { float saldo; public: Caja(){saldo=1000;}

void Ingresa(float cantidad){saldo+=cantidad;} void Saca(float cantidad){saldo-=cantidad;} }; class Personaje { protected: float saldo; Personaje* interlocutor; public: Personaje(){saldo=100;}

void Conecta(Personaje* p){interlocutor=p;}

virtual void Recibe(float cantidad){saldo+=cantidad;} };

class Cajero : public Personaje {

Caja* p_caja; public:

void Gestiona(Caja* c){p_caja=c;} void Recibe(float cantidad)

{ p_caja->Ingresa(cantidad); p_caja->Saca(cantidad*0.05f); saldo+=cantidad*0.05f; } };

class Jugador : public Personaje {

public:

void Paga(float cantidad)

{saldo-=cantidad;interlocutor->Recibe(cantidad);} }; int main() { Cajero cajero; Jugador jugador; Caja caja; jugador.Conecta(&cajero); cajero.Gestiona(&caja); jugador.Recibe(300); jugador.Paga(50); return 0; }

(5)

NOMBRE Nº Mat.

4. Problema de Sistemas Operativos (7,5 puntos - 45 minutos)

Conteste en el espacio reservado al efecto

Se desea diseñar un sistema de recomendación de hoteles, restaurantes y bares, similar al sistema de

TripAdvisor. Para ello se diseña una solución Cliente-Servidor, con servidor dedicado, que atiende a cada

cliente que solicita información o introduce información sobre dichos establecimientos.

Los usuarios pueden conectarse al sistema a través de una app, que se instala en el móvil, o a través de un

navegador web, accediendo a una determinada página web. Sea cual sea la manera de conectarse, el cliente

contactará al servidor para realizar una consulta sobre un establecimiento o insertar comentarios sobre un

determinado establecimiento.

Para diseñar el servidor, se utiliza una base de datos que se implementa como un conjunto de ficheros, un

fichero para los hoteles, otro para los restaurantes y otro para los bares.

a) [1,5 ptos] Indicar para el escenario propuesto las ventajas y desventajas de Cliente-servidor con servidor

dedicado frente a una solución de Cliente-Servidor serie.

La solución cliente-servidor con servidor dedicado consiste en que el servidor crea un proceso hijo o un hilo que atiende las peticiones del cliente, pudiendo el servidor principal atender a otros clientes de manera concurrente. Por tanto, esta solución proporciona todas las ventajas que ofrece la concurrencia, siendo más eficiente esta solución para atender varios clientes. Por el contrario, la solución de Cliente-Servidor serie serializa los accesos de los clientes, como su nombre indica, provocando contención en otros clientes que no serán atendidos hasta que el cliente anterior finalice. La ventaja de esta última solución es que no tiene problemas de concurrencia, dado el carácter serie de dicha solución. Pero es inadmisible si un cliente lleva a cabo un servicio muy largo.

b) [1,5 ptos] Indicar el mecanismo que debería utilizar la parte cliente de la aplicación para conectarse con el

servidor cuando envía un comentario sobre un determinado establecimiento. Justificar la respuesta.

Dado que se trata de diferentes máquinas, necesitamos utilizar sockets. Como no queremos perder ningún mensaje por parte de los clientes, se utilizarán sockets de tipo stream, utilizando protocolo TCP.

c) [1,5 ptos] Implementar en código C dicho cliente. Suponed que el comentario mandado es una cadena de

caracteres.

int main(int argc, char * argv[]){ /* suponemos que argv[1] contiene el nombre del servidor y argv[2] el mensaje a mandar*/

int cd;

struct hostent * hp; struct sockaddr_in s_ain; hp = gethostbyname(argv[1]);

bzero((char *)&s_ain, sizeof(s_ain)); s_ain.sin_family = AF_INET;

memcpy (&(s_ain.sin_addr), hp->h_addr, hp->h_length); s_ain.sin_port = htons(PORT_NUMBER);

cd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

connect(cd, (struct sockaddr *)&s_ain, sizeof(s_ain)); // suponemos que BUFF_SIZE es el tamaño máximo del mensaje sendv(cd, argv[2], BUFF_SIZE, 0);

close(cd); return 0; }

(6)

Los hilos van a poder acceder concurrentemente a los diferentes ficheros. Mientras que no hay problema en leer los ficheros de manera concurrente, la modificación de una zona del fichero debe hacerse en exclusión mutua. Se trata de un problema típico lectores-escritores. Podríamos utilizar diferentes mecanismos, como mutex y condiciones (que están recomendados para hilos), pero dado que se trata de ficheros, el uso de cerrojos nos facilita el establecer las restricciones de acceso de lectura y escritura sobre diferentes zonas de los mismos. Por tanto, elegiríamos los cerrojos como mecanismo de sincronización.

Aparte del proceso gest_recomend, en la parte servidora y dentro de la misma máquina, hay otro proceso

pesado denominado backup, que se encarga de ir almacenando todos los cambios en un fichero denominado

fich_backup. El proceso backup duerme y cada 30 minutos se despierta para ir volcando los cambios

producidos. El proceso gest_recomend utiliza un FIFO para comunicarle los cambios al proceso backup, que

los lee, volcándolos al fichero fich_backup.

e) [1,5 ptos] Implementar en código C el proceso backup. Considerar que los cambios se representan por una

cadena de caracteres que se irá agregando al final del fichero fich_backup.

Por simplicidad, no se tratan los posibles errores int main(int argc, char * argv[]){

int fifo, fd;

char mensaje[BUFF_SIZE]; while (1) {

/* se supone que el FIFO ha sido creado por el proceso gest_recomend */ fifo = open(“fifo_backup”, O_RDONLY);

/* se abre el fichero fich_backup para escribir al final y crearlo si es la primera vez */

fd = open (“fich_backup”,O_CREAT | O_WRONLY | O_APPEND, 0666); read(fifo, mensaje, BUFF_SIZE);

write(fd, mensaje, BUFF_SIZE); close(fifo); close(fd); sleep(30*60); } return 0; }

(7)

NOMBRE Nº Mat.

5. Problema de Sistemas Operativos (7,5 puntos - 45 minutos)

Conteste en el espacio reservado al efecto

a) [2,5 ptos] Un usuario invoca desde el terminal el mandato programaA. Este proceso crea un hijo. El

proceso padre envía al hijo la señal SIGUSR1 transcurridos 3 segundos desde el inicio de la ejecución del

proceso padre y el proceso hijo imprime un mensaje por la salida estándar indicando que se ha producido la

recepción de la señal. El proceso hijo debe ejecutar el mandato “ls -alt /tmp” una vez que han pasado 10

segundos desde su creación. Al concluir la ejecución del proceso hijo tras la ejecución del mandato ls,

también debe mostrarse al usuario en el terminal los identificadores de ambos procesos. Especifique el

código necesario para que los procesos completen la ejecución correctamente y que ambos siempre

devuelvan el estado en el que terminan su ejecución.

pid_t pid;

void funcion1(int senal){ if (senal == SIGUSR1)

printf("Se ha recibido la Senal SIGUSR1\n"); else if (senal == SIGALRM)

{

printf("Han transcurrido los 10 segundos\n"); execlp("ls","ls","-alt","/tmp",NULL);

perror("No se ha podido ejecutar el exec"); exit(1);

} }

void funcion2(int senal){ aux=kill(pid,SIGUSR1); if (aux == -1) perror("kill SIRUSR1"); } int main(void) {

int status; struct sigaction act; act.sa_handler=&funcion2; act.sa_flags=SA_RESTART; sigaction(SIGALRM,&act,NULL); alarm(3); pid=fork(); if (pid == -1)

{perror("Error en fork"); exit(1);} else if (pid == 0){ act.sa_handler=&funcion1; act.sa_flags=SA_RESTART; sigaction(SIGUSR1,&act,NULL); sigaction(SIGALRM,&act,NULL); alarm(10); while (1) {} } else { pid=wait(&status); if (pid>0)

printf("Fin del hijo: %d\n",pid); else

perror("Error en el wait"); printf("Fin del padre: %d\n",getpid()); }

return 0; }

(8)

proceso que debían mostrarse al usuario una vez concluida la ejecución del mandato ls no podrían mostrarse en este caso.

c) [1 pto] Describa las posibles situaciones que pueden darse ante la finalización de un proceso hijo con pid

4444 en función de si el padre con pid 333 termina antes que él. Suponga la siguiente jerarquía de procesos:

1-22-333-4444-55555

El proceso hijo 4444 puede quedar huérfano si el padre 333 ha invocado el servicio wait antes de su finalización. En este caso, el hijo es heredado por el proceso init 1 que espera en un bucle infinito la terminación de sus hijos.

También puede quedar como zombi si termina y el proceso padre 333 no ha hecho un wait. En este caso, no puede entregar el estado de terminación al padre y no se libera su entrada en la tabla de procesos.

d) [1 pto] Enumere señales que al recibirlas un proceso, su acción por defecto no provoca su muerte.

SIGCHLD, SIGSTOP, SIGCONT

e) [1,5 ptos] En un sistema UNIX que dispone de memoria virtual con páginas de 8 KiB, indique cómo pueden

compartir una región de memoria un proceso padre con sus hijos sin que exista soporte físico de esta región

en el sistema de ficheros. El tamaño solicitado para la región será de 15 KB. Especifique la invocación del

servicio que permite crear esta región e indique cuál será el tamaño de la región tras su creación.

Antes de la invocación del servicio fork para crear los hijos, el proceso padre crea una región en memoria con el servicio mmap activando el flag MAP_SHARED, que permite compartir la región entre varios procesos, y utilizando el flag MAP_ANONYMOUS, que no asocia la región a ningún fichero en disco:

char *p;

p=mmap(NULL,15000,PROT_READ|PROT_WRITE,MAP_SHARED|MAP_ANONYMOUS,-1,0);

Como el tamaño de la región debe ser múltiplo de la página del sistema, la solicitud de 15 KB se convertirá en una región de 16 KiB.