examen adin

#include
#include
#include

#define N 5
#define IZQ (i-1)%N
#define DER (i+1)%N
#define TOMA 0
#define AGARRAOTRO 1
#define COME 2


pthread_t filos[N];
sem_t mutex ;
sem_t s[N];
int estado [N] ;



void aga (int i)
{
int t ;
t = rand() % 11;
printf("Filosofo %d agarra un palillo \n", i) ;
estado[i] = TOMA;
sleep (t) ;
}



void comer (int i)
{
printf("Filósofo %d agarra otro palillo \n", i);
estado[i] = COME;
sleep (5);
}



void agar(int i)
{
if( estado[i]==AGARRAOTRO && estado[IZQ]!=COME && estado[DER]!=COME ){
estado[i] = COME;
printf("Filósofo %d comiendo\n", i) ;
sem_post(&s[i]);
}
}



void toma_tndrs(int i)
{

sem_wait(&mutex);
estado[i] = AGARRAOTRO;
agar(i);
sem_post(&mutex);
sem_wait(&s[i]);
}



void deja_tndrs(int i)
{

sem_wait(&mutex);
estado[i] = TOMA;
agar(IZQ);
agar(DER);
sem_post(&mutex);
}


void * filosofos (int i)
{
int j ;


for (; ; )
{
aga(i) ;
toma_tndrs(i) ;
comer(i) ;
deja_tndrs(i) ;
}
}


main()
{
int i ;


for(i = 0; i < 5; i++){
sem_init (&s[i], 0, 1);


estado[i] = TOMA ;
}


sem_init (&mutex, 0, 1);


for (i=0; ipthread_create(&filos[i], NULL, (void *)filosofos,(void *) i);


for (i=0; ipthread_join(filos[i],NULL);
}

}

proceso padre hijo aleatorio

el progama usa las estructuras que hemos estado utilizando anteriormente, con la misma logica clonar porcesos para determinar los procesos padres y despues los hijos,
ahora

se inicializa con un random, el proceso padre para generar un numero, despues de generar el el numero aleatorio y el proceso padre se genera el proceso hijo, deve tener el numero consecutivo del proceso por lo cual se ace un incremento de una unidad y de esta forma se produce el incremento

en la segunda parte se invierten los procesos y se inicializan de forma invertida para que el proceso padre obtenga el valor del hijo y de esta forma el proceso sucesivo procede a ser padre.

Codigo.

#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include

#define lectura 0
#define escritura 1


int aleatorio(void)
{
int semilla = (int)time(NULL);
srand(semilla);
}

int hijo(int tube1[2], int tube2[2]){
int ret;
int minumero;

int numbytes;
char buf[256]={};

ret = fork();

if (ret == 0){
/*Tratamiento del nieto*/
//minumero = aleatorio();
minumero= 10;

printf("%d\n",minumero);
sprintf(buf,"%d",minumero);

if( write (tube1[escritura],buf, sizeof(buf)) == -1){
perror("Fallo write nieto");
exit(EXIT_FAILURE);
}

numbytes = read(tube2[lectura],buf,sizeof(buf));

if (numbytes == -1){
perror("Fallo read nieto");
exit(EXIT_FAILURE);
}



close(tube1[escritura]);
close(tube2[lectura]);

printf("Soy hijo2 con PID=%d, mi número aleatorio es %d y el del otro proceso es %s\n",getpid(),minumero,buf);


}

else if (ret > 0){
/*Tratamiento del padre*/

//minumero = aleatorio();
minumero=32;

printf("%d\n",minumero);
sprintf(buf,"%d",minumero);

if( write (tube2[escritura],buf, sizeof(buf)) == -1){
perror("Fallo write padre");
exit(EXIT_FAILURE);
}

numbytes = read(tube1[lectura],buf,sizeof(buf));

if (numbytes == -1){
perror("Fallo read padre");
exit(EXIT_FAILURE);
}




close(tube1[lectura]);
close(tube2[escritura]);

printf("Soy hijo1 con PID=%d, mi número aleatorio es %d y el del otro proceso es %s\n",getpid(),minumero,buf);
}

else if (ret == -1){
/*Error*/
perror("Fallo en el segundo fork");
exit(EXIT_FAILURE);
}
}

int main (void){
int ret;
int ret2;
int tube1[2];
int tube2[2];
int temp;
int e;
char buf[256]={};

if (pipe(tube1) == -1){
perror("Fallo pipe1");
exit(EXIT_FAILURE);
}

if (pipe(tube2) == -1){
perror("Fallo pipe2");
exit(EXIT_FAILURE);
}

ret = fork();

if (ret == 0){
/*tratamiento del hijo*/
hijo(tube1,tube2);

}

else if( ret > 0){
/*tratamiento del abuelo*/


}

else if (ret == -1){
/*error*/
perror("Fallo en fork");
exit(EXIT_FAILURE);
}

ret = wait (NULL);

while (ret > 0){
ret = wait(NULL);
}

if (ret == -1 && errno != ECHILD){
perror("Fallo en wait");
exit (EXIT_FAILURE);
}

}

posix tarea

Son una familia de estándares de llamadas al sistema operativo definidos por el IEEE y especificados formalmente en el IEEE 1003. Persiguen generalizar las interfaces de los sistemas operativos para que una misma aplicación pueda ejecutarse en distintas plataformas. Estos estándares surgieron de un proyecto de normalización de las API y describen un conjunto de interfaces de aplicación adaptables a una gran variedad de implementaciones de sistemas operativos.

Especifica las interfaces de usuario y software al sistema operativo en 15 documentos diferentes. La línea de comandos estándar y las interfaces de scripting se basaron en Korn Shell. Otros programas a nivel de usuario (user-level), servicios y utilidades incluyen AWK, echo, ed y cientos de otras. Los servicios a nivel de programa requeridos incluyen definición de estándares básicos de I/O, (file, terminal, y servicios de red). También especifican una API para las bibliotecas de threading, que es muy utilizada en una gran variedad de sistemas operativos.

Una serie de pruebas acompañan al estándar POSIX. Son llamadas "PCTS" en alusión al acrónimo "Posix Conformance Test Suite". Desde que la IEEE empezó a cobrar altos precios por la documentación de POSIX y se ha negado a publicar los estándares, ha aumentado el uso del modelo Single Unix Specification. Este modelo es abierto, acepta entradas de todo el mundo y está libremente disponible en Internet. Fue creado por The Open Group.

POSIX.1, Core Services (implementa las llamadas del ANSI C estándar). Incluye:
Creación y control de procesos.
Señales.
Excepciones de punto flotante.
Excepciones por violación de segmento.
Excepciones por instrucción ilegal.
Errores del bus.
Temporizadores.
Operaciones de ficheros y directorios (sobre cualquier fs montado).
Tuberías (Pipes).
Biblioteca C (Standard C).
Instrucciones de entrada/salida y de control de dispositivo (ioctl).
POSIX.1b, extensiones para tiempo real:
Planificación (scheduling) con prioridad.
Señales de tiempo real.
Temporizadores.
Semáforos.
Intercambio de mensajes (message passing).
Memoria compartida.
Entrada/salida síncrona y asíncrona.
Bloqueos de memoria.
POSIX.1c, extensiones para hilos (threads):
Creación, control y limpieza de hilos.
Planificación (scheduling).
Sincronización.
Manejo de señales.
POSIX.2, Shell y Utilidades (IEEE Std 1003.2-1992)
Intérprete de Comandos
Programas de Utilidad
Luego de 1997 el Grupo Austin realizó modificaciones a POSIX. Las especificaciones tienen el nombre de Single Unix Specification (Especificación Única de Unix)

POSIX:2001 o IEEE Std 1003.1-2001 equivale a la versión 3 de Single UNIX Specification.
Las base de definiciones,
Las interfaces y encabezamientos del sistema,
Los comandos y utilidades, .
POSIX:2004 o IEEE Std 1003.1-2004 implica una pequeña actualización de POSIX:2001. Tiene dos correcciones técnicas de errores. Para más información sobre este estándar visitar: http://www.opengroup.org/onlinepubs/009695399/
A partir de 2009 POSIX:2008 o IEEE Std 1003.1-2008 representa la versión actual.
La base de definiciones, ,
Las interfaces encabezamientos del sistema, .
Los comandos y utilidades,

TOTALMENTE POSIX-COMPATIBLES

Los siguientes Sistemas Operativos son 100% compatibles con uno o varios estándares POSIX.

A/UX
AIX
BSD/OS
DSPnano
HP-UX
INTEGRITY
IRIX
LynxOS
Mac OS X v10.5 en Procesadores Intel.
MINIX
MPE/iX
QNX (IEEE Std. 1003.13-2003 PSE52;
RTEMS (POSIX 1003.1-2003 Profile 52)
Solaris
Unison RTOS
UnixWare
velOSity
VxWorks (IEEE Std. 1003.13-2003 PSE52;

MAYORMENTE POSIX-COMPATIBLES

Los siguientes, aunque no oficialmente certificados como POSIX-compatibles, se ajustan en gran parte

BeOS / Haiku
FreeBSD
GNU/Linux (la mayor parte de las distribuciones)
Contiki
NetBSD
Nucleus RTOS
OpenBSD
OpenSolaris
PikeOS
RTOS (para ciertos sistemas con particiones PSE51 y PSE52 opcionales)
RTEMS – Soporte API POSIX diseñado para IEEE Std. 1003.13-2003 PSE52
Sanos
SkyOS
Syllable
VSTa

POSIX PARA WINDOWS

Cygwin ofrece un desarrollo en gran parte compatible con POSIX y un entorno de ejecución para Microsoft Windows.
Microsoft POSIX subsystem, un subsistema opcional Windows
Windows Services for UNIX de Microsoft permite una plena compatibilidad POSIX para ciertos productos de Microsoft Windows. Los sistemas operativos basados en Windows NT hasta Windows 2000 tenían una interfaz POSIX incorporada en el sistema operativo y los Servicios UNIX para Windows brindaban un entorno del tipo UNIX. Para Windows XP, los Servicios UNIX para Windows deben de instalarse para que exista compatibilidad POSIX. El subsistema UNIX está incorporado a las ediciones Enterprise y Ultimate de Windows Vista y 7, y no pueden ser agregados en forma separada a las otras ediciones..
UWIN de AT&T Research implementa una capa POSIX sobre la interfaz de programa de aplicaciones (API) de Win32

practica 3

esta es la practica tres aqui podemos observar una macros cuando indicamos la sentencia "#define esta directis es utilizada para consultar informacion del api y de esta forma utilizar funciones que no estan prestablecidas en el lenguaje

este programa es capaz de identificar el tipo de pid podemos observar claramente como
hace referencia al proceso padre y al proceso hijo, tambien se logra obtener el numero del proceso

de esta forma podemos interpretar la logica que se utiliza cuando se ejecuta un proceso y secuencialmente un proceso hijo,

algo que me parecio importante fue el hecho de modificar el codigo para obtener otros valores del proceso y para esto tuve que modificar la macros que se define en el programa de esta forma los porcesos adquieren valores diferentes tambien las condiciones que manejan las esepciones en el programa, cuando exista un error mandar un el mensaje del programa finalizar y no permitir que el sistema caiga. cuando los if comparan o igual a o y igual a -1 los posibles casos que puedan ejecutarse

practica 2

lo interesante que logre observar en este codigo sobre todo fue al inicio en el main, podemos notar que los parametros no son vacios como normalmente se acostumbra a definir con un void auqi podemos ver que el main recibe paramentros esto es algo que se ve pocas veces normalemte se utiliza este tipo de parametros para obtener datos prestablecidos del afuera y poder ocuparlos dentro de los procesos

tambien como podemos ver utilizamos una variable de tipo file archivo el * representa el puntero para indicar la direccion de memoria, tambien es facil identificar la utilizacion de de arreglos dentro del porgrama para tener un control mas ordenado de los valores y aparte para reducir declarar variables es un atajo que utilizamos los programadores para evitar hacer codigos muy largos e inentendibles

se utilisa nuevamente la funcion getpid la que se encarga de obtener el valor de pid y propiamente introducirlo en una variable, la funcion gets para facilitar el manejo de los arreglos de caracteres que se utilizan

en el while es inportante mensionar lo que pasa como estamos utilizando archivos en la ejecucion dle programa las funciones como fgets nos sirven para almacenar informacion dentro del archivo
podemos notar en las llines finales un fclous que sierra el archivo y en las iniciales un fopen que abre el mismo para utilizarlo

basicamente se manejan procesos y se identifican procesos primarios (padres) y las instancias que estos ejecutan procesos hijos

el porgrama cumple la funcion de manejar procesos
crea procesos y los clona con la funcion fork tambien despliega porcesos hijos
los cuales son extenciones de los procesos padre

es un programa donde es facil observar la logica del funcionamiento basico de esta forma
podemos darnos una y idea y sobretodo conocer como arranca un porceso los atributos que puede tener como ejecutar procesos hijos hay funciones importantes que quisiera mensionar
y partes del codigo.

por ejemplo podemos ver como se incializa una variable a la funcion fork, de esta forma la variable toma el valor del proceso que se ejecutara,
la funcion get la cual se engarga de consegir el valor de la funcion a la cual se esta apuntando en este caso es a pid
la funcion sleep esta es usada para dar un determinado tiempo, detener la ejecusion y al termino del tiempo dado seguir continuado con la siguiente sentencia que se encuentre en el programa

algo interesante que note fue el break dentro del if que esta en el for es importante comentar lo que sucede si llega a entrar a ese if el for es truncado son importar las pasadas que haya realizado es raro ver un break dentro de un for, por eso hago el comentario normalmente el break dentro de un for se pone cuando son bucles infinitos for(;;) la sentencia se escribe de esta forma sin llenar algun dato de los parametros

android

Android es un sistema operativo basado en GNU/Linux diseñado originalmente para dispositivos móviles, tales como teléfonos inteligentes, pero que posteriormente se expandió su desarrollo para soportar otros dispositivos tales como tablets, reproductores MP3, netbooks, PCs, televisores, lectores de e-books e incluso, se han llegado a ver en el CES, microondas y lavadoras .

Fue desarrollado inicialmente por Android Inc., una firma comprada por Google en 2005. Es el principal producto de la Open Handset Alliance, un conglomerado de fabricantes y desarrolladores de hardware, software y operadores de servicio. Las unidades vendidas de teléfonos inteligentes con Android se ubican en el primer puesto en los Estados Unidos, en el segundo y tercer trimestres de 2010, con una cuota de mercado de 43,6% en el tercer trimestre.

Android tiene una gran comunidad de desarrolladores escribiendo aplicaciones para extender la funcionalidad de los dispositivos. A la fecha, se han sobrepasado las 250.000 aplicaciones disponibles para la tienda de aplicaciones oficial de Android: Android Market, sin tener en cuenta aplicaciones de otras tiendas no oficiales para Android, como pueden ser la App Store de Amazon o la tienda de aplicaciones de Samsung. Android Market es la tienda de aplicaciones en línea administrada por Google, aunque existe la posibilidad de obtener software externamente. Los programas están escritos en el lenguaje de programación Java.[18] No obstante, no es un sistema operativo libre de malware, aunque la mayoría de ello es descargado de sitios de terceros.

El anuncio del sistema Android se realizó el 5 de noviembre de 2007 junto con la creación de la Open Handset Alliance, un consorcio de 78 compañías de hardware, software y telecomunicaciones dedicadas al desarrollo de estándares abiertos para dispositivos móviles.[20] [21] Google liberó la mayoría del código de Android bajo la licencia Apache, una licencia libre y de código abierto.[22] Actualmente Android posee aproximadamente el 32,9% de cuota de mercado a escala mundial de los teléfonos inteligentes, por delante de Symbian OS que posee una cuota aproximada del 30,6%. En tercer lugar se sitúa iOS con una cuota de mercado del 16%.

La estructura del sistema operativo Android se compone de aplicaciones que se ejecutan en un framework Java de aplicaciones orientadas a objetos sobre el núcleo de las bibliotecas de Java en una máquina virtual Dalvik con compilación en tiempo de ejecución. Las bibliotecas escritas en lenguaje C incluyen un administrador de interfaz gráfica (surface manager), un framework OpenCore, una base de datos relacional SQLite, una API gráfica OpenGL ES 2.0 3D, un motor de renderizado WebKit, un motor gráfico SGL, SSL y una biblioteca estándar de C Bionic. El sistema operativo está compuesto por 12 millones de líneas de código, incluyendo 3 millones de líneas de XML, 2,8 millones de líneas de lenguaje C, 2,1 millones de líneas de Java y 1,75 millones de líneas de C++.

Adquisición por parte de GoogleEn julio de 2005, Google adquirió Android Inc., una pequeña compañía de Palo Alto, California fundada en 2003. Entre los cofundadores de Android que se fueron a trabajar a Google están Andy Rubin (co-fundador de Danger), Rich Miner (co-fundador de Wildfire Communications, Inc.),[25] Nick Sears (alguna vez VP en T-Mobile), y Chris White (quien encabezó el diseño y el desarrollo de la interfaz en WebTV). En ese entonces, poco se sabía de las funciones de Android Inc. fuera de que desarrollaban software para teléfonos móviles. Esto dio pie a rumores de que Google estaba planeando entrar en el mercado de los teléfonos móviles.

En Google, el equipo liderado por Rubin desarrolló una plataforma para dispositivos móviles basada en el kernel de Linux que fue promocionado a fabricantes de dispositivos y operadores con la promesa de proveer un sistema flexible y actualizable. Se informó que Google había alineado ya una serie de fabricantes de hardware y software y señaló a los operadores que estaba abierto a diversos grados de cooperación por su parte.

La especulación sobre que el sistema Android de Google entraría en el mercado de la telefonía móvil se incrementó en diciembre de 2006. Reportes de BBC y The Wall Street Journal señalaron que Google quería sus servicios de búsqueda y aplicaciones en teléfonos móviles y estaba muy empeñado en ello. Medios impresos y en línea pronto reportaron que Google estaba desarrollando un teléfono con su marca.

En septiembre de 2007, «InformationWeek» difundió un estudio de Evalueserve que reportaba que Google había solicitado diversas patentes en el área de la telefonía móvil.

Open Handset AllianceEl 5 de noviembre de 2007 la Open Handset Alliance, un consorcio de varias compañías entre las que están Texas Instruments, Broadcom Corporation, Nvidia, Qualcomm, Samsung Electronics, Sprint Nextel, Intel, LG, Marvell Technology Group, Motorola, y T-Mobile; se estrenó con el fin de desarrollar estándares abiertos para dispositivos móviles.[11] Junto con la formación de la Open Handset Alliance, la OHA estrenó su primer producto, Android, un plataforma para dispositivos móviles construidas en la versión 2.6 del kernel de Linux.

El 9 de diciembre de 2008, se anunció que 14 nuevos miembros se unirían al proyecto Android, incluyendo PacketVideo, ARM Holdings, Atheros Communications, Asustek, Garmin, Softbank, Sony Ericsson, Toshiba y Vodafone.

Historial de actualizacionesAndroid ha visto numerosas actualizaciones desde su liberación inicial. Estas actualizaciones al sistema operativo base típicamente arreglan bugs y agregan nuevas funciones. Generalmente cada actualización del sistema operativo Android es desarrollada bajo un nombre en código de un elemento relacionado con postres.

Android ha sido criticado muchas veces por la fragmentación que sufren sus terminales al no ser soportado con actualizaciones constantes por los distintos fabricantes. Sin embargo, esa situación cambiará con un anuncio que hizo oficial Google en el que comunicó que los fabricantes se comprometerán a aplicar actualizaciones al menos 18 meses desde su salida al mercado

Los nombres en código están en orden alfabético.