#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <errno.h> // define macros que presenta un informe de error atravez de codigos
#define NUM_HIJOS 2 //
int main(void)
{
int ret, i;
for(i=1; i<NUM_HIJOS; i++)
{
ret=fork();
if(ret == 0){
printf("yo soy el hijo %d, PID = %d,mi randon es %d, el del otro proceso = %d \n",i, getppid(), rand() %100, getpid());
srand(time(NULL));
if(i==1){
srand(1);
printf("yo soy el hijo %d, PID = %d , mi random es %d, el otro proceso es = %d\n",i+1, getppid(), getpid(), rand() %100 );
POSIX es el acrónimo de Portable Operating System Interface; la X viene de UNIX como seña de identidad de la API.
El término fue sugerido por Richard Stallman en respuesta a la demanda de la IEEE, que buscaba un nombre fácil de recordar. Una traducción aproximada del acrónimo podría ser "Interfaz de sistema operativo portable". ".
INTRODUCCION
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).
Tuberias(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.
Temporalizadores
semaforos
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, Tema 6.
Las interfaces y encabezamientos del sistema, Tema 6.
Los comandos y utilidades, Tema 6.
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:
A partir de 2009 POSIX:2008 o IEEE Std 1003.1-2008 representa la versión actual.
La base de definiciones, Tema 7,
Las interfaces encabezamientos del sistema, Tema 7.
Los comandos y utilidades, Tema 7.
EJEMPLO:
sistema productor-consumidor con búfer circular utilizando hilos, semáforos POSIX binarios y semáforos POSIX genéricos:
#include <stdio.h> #include <string.h> #include <errno.h> #include <pthread.h> #include <semaphore.h> #define TAMBUF 8 // Tamaño del búfer circular #define NUMDATOS 100 // Número de datos a enviar // // El buffer circular y los correspondientes punteros int buffer[TAMBUF]; int bufin = 0; int bufout = 0; // // Semaforo binario pthread_mutex_t buffer_lock = PTHREAD_MUTEX_INITIALIZER; // // Variable suma unsigned long sum = 0; // // Semaforos generales sem_t hay_datos; sem_t hay_sitio; // // Funciones de escritura y lectura del buffer circular void obten_dato(int *itemp) { pthread_mutex_lock(&buffer_lock); *itemp = buffer[bufout]; bufout = (bufout + 1) % TAMBUF; pthread_mutex_unlock(&buffer_lock); return; } void pon_dato(int item) { pthread_mutex_lock(&buffer_lock); buffer[bufin] = item; bufin = (bufin + 1) % TAMBUF; pthread_mutex_unlock(&buffer_lock); return; }
// // Funciones productor-consumidor void *productor(void *arg1) { int i; for (i = 1; i <= NUMDATOS; i++) { sem_wait(&hay_sitio); pon_dato(i*i); sem_post(&hay_datos); } pthread_exit( NULL ); } void *consumidor(void *arg2) { int i, midato; for (i = 1; i<= NUMDATOS; i++) { sem_wait(&hay_datos); obten_dato(&midato); sem_post(&hay_sitio); sum += midato; } pthread_exit( NULL ); }
// // Funcion principal main() { pthread_t tidprod, tidcons; unsigned long i, total;
total = 0; for (i = 1; i <= NUMDATOS; i++) total += i*i; printf("El resultado deberia ser %u\n", total); // // Inicializacion de semaforos sem_init(&hay_datos, 0, 0); sem_init(&hay_sitio, 0, TAMBUF); // // Se crean los hilos pthread_create(&tidprod, NULL, productor, NULL); pthread_create(&tidcons, NULL, consumidor, NULL); // // Se espera a que los hilos terminen pthread_join(tidprod, NULL); pthread_join(tidcons, NULL); printf("Los hilos produjeron el valor %u\n", sum);
/**ATENCIÓN: Declaración de variables del programa a probar. Es sólo un exemplo**/
int i;
int n = 4;
int childpid;
/**El resto de variables son para que la presentación de los resultados por pantalla sea posible**/
int a, p;
int ret;
FILE *fpipe;
char comanda[50]; /*String dónde se guarda el comando a ejecutar por el 1r hijo*/
char line[256];
p = getpid();
sprintf(comanda,"pstree -n -p %d\n",getpid()); /*Concatenamos el comando pstree con el pid del padre*/
ret = fork();
if (ret == 0) { /*Este es el primer hijo del padre*/
if ( !(fpipe = (FILE*)popen(comanda,"r")) ) { /* Si el pipe falla*/
perror("Problemas con el pipe!!!");
exit(1);
}
while ( fgets( line, sizeof line, fpipe))
{
printf("%s", line); /*Escribimos por pantalla lo que retorna el hijo. La salida del pstree*/
}
pclose(fpipe);
} else {
/*El primer hijo sólo se crea para hacer un pstree y poder ver por pantalla */
/*el árbol de procesos generado*/
/*El código que viene a continuación, lo podéis substituir por lo que se tercie*/
/*¡¡Las variables han de ir declaradas arriba!!!*/
for (i = 1; i < n; i++) {
if ((childpid = fork()) == -1) {
break;
}
fprintf(stderr, "Este es el proceso %ld com padre %ld\n", (long)getpid(), (long)getppid());
}
sleep(1); /*Es sólo para dar tiempo a terminar a todos los hijos*/
}
exit(0);
}
EL PROGRAMA COMPILADO SE MUESTRA ASI
Este es el proceso 2311 com padre 2093
Este es el proceso 2311 com padre 2093
Este es el proceso 2314 com padre 2311
Este es el proceso 2311 com padre 2093
Este es el proceso 2314 com padre 2311
Este es el proceso 2315 com padre 2311
Este es el proceso 2313 com padre 2311
Este es el proceso 2313 com padre 2311
Este es el proceso 2316 com padre 2314
Este es el proceso 2313 com padre 2311
Este es el proceso 2319 com padre 2313
Este es el proceso 2318 com padre 2313
Este es el proceso 2318 com padre 2313
Este es el proceso 2320 com padre 2318
programakika(2311)-+-programakika(2312)---sh(2317)---pstree(2321)
|-programakika(2313)-+-programakika(2318)---programakika(2320)
| `-programakika(2319)
|-programakika(2314)---programakika(2316)
`-programakika(2315)
PREGUNTAS
¿Por que se repite tantas veces?
van apareciendo todos los procesos tanto padres como hijos
¿Que puedes observar?
Que los procesos se muestran de forma aleatoria desordenada al momento de mostrarse, se puede vizualizar que el id (pid) de los padres es aun mas bajo que el de los hijos y con la funcion pstree que es un comando que permite ver al arbol de procesos de sistema se acomodan los procesos.
¿Porque?
El comando pstree de permite ver al árbol de procesos del sistema.
En los sistemas operativos GNU Linux, para visualizar ese arbol podemos hacerlo a través del comando pstree.
Por ejemplo, ejecutamos pstree -pl, donde los argumentos p y l, respectivamente muestran los pid de los procesos y no truncan líneas largas.
Otra alternativa, es utilizar el clásico ps, especificando el argumento --forest. Por ejemplo, ps axl --forest
for(num=0; num<3; num++)
{
pid=fork();
printf("soy el progreso pid --> [%d] y mi padre tiene -->[%d] de pid\n", getpid(),getppid());
if(pid !=0 )
break;
srandom(getpid());
sleep(random()%3);
}
if(pid !=0);
printf("fin del proceso de pid %d\n",wait(NULL));
return 0;
}
¿Por que se repite tantas veces? Por dos funciones: fork- por la cual aparecen repetidos y la funcion srandom para los numeros aleatorios
¿Que puedes observar?
En el proceso se observa que el proceso es mayor que el padre
ejemplo
soy el proceso PID 3052 y mi PADRE 3051
FUNCIONES
Que es:
Fork:
La forma en que un proceso arranca a otro es mediante una llamada al sistema fork o clone.
1. La función fork de la librería libc coloca los parámetros de la llamada
en los registros del procesador y se ejecuta la instrucción INT 0x80.
2. Se conmuta a modo núcleo y, mediante las tablas IDT y GDT, se llama
a la función sys_call.
3. La función sys_call busca en la sys_call_table la dirección de la
llamada al sistema sys_fork
SRANDOM
Funcion en c estadar llamada random(). Si quieres generar un numero aleatorio deberas utilizar srand() y rand(). Para hacer uso de ellas debes incluir stdlib.h
delay () o sleep ()
<windows.h> Sleep() // retraso en milisegundos
<dos.h> sleep() // retraso en segundos.
Turbo C + + no es una función llamada delay (), y en el compilador de Microsoft, supongo que es el sueño o sleep. lo que podría ser la posible función equivalente a la que se puede utilizar cuando se compila en GCC.
Wait.
Obligará a un proceso padre que esperar a que un proceso hijo para detener o poner fin a wait () devuelve el pid del hijo o -1 para un error.. El estado de salida del niño es devuelto.
LIBRERIAS
#include <dos.h> //esta es la librería para usar sleep
La cabecera <sys/types.h> incluye definiciones para al menos los siguientes tipos:
id_t
Se utiliza como identificador general, se puede utilizar para contener al menos un pid_t, uid_t o gid_t una.
ino_t
Utilizados para el archivo de números de serie.
key_t
Se utiliza para la comunicación.
mode_t
Se utiliza para algunos de los atributos de archivo.
nlink_t
Se utiliza para el conteo de enlaces.
off_t
Se utiliza para tamaños de archivo.
pid_t
Se utiliza para los identificadores de proceso y los ID de proceso del grupo.
La cabecera <sys/wait.h> define las siguientes constantes simbólicas para su uso con waitpid () :
El tipo idtype_t se define como un tipo de enumeración cuyos valores posibles son al menos lo siguiente:
Chrome OS está diseñado de una forma minimalista, debido a que su principal herramienta es el navegador webGoogle Chrome. De esta forma, la compañía planea mover gran parte de la interfaz de usuario desde un entorno de escritorio hacia Internet. De hecho, Google se refiere a su proyecto Chrome OS como una extensión natural del navegador Chrome. En otras declaraciones para una audiencia de desarrolladores, Google enfatiza que la web es la plataforma, destacando que las aplicaciones basadas en web funcionarán en Chrome y viceversa.
Las principales características de la interfaz de usuario son:
Paneles: Los paneles son pequeñas ventanas inferiores que se utilizan para diferentes tareas, tales como la descarga de archivos, navegador de archivos, mensajería instantánea en Gtalk, tomar notas, o notificadores de eventos como Google Calendar, Gmail, y actualizaciones del sistema. Los paneles también permiten ser minimizados para ocultarse, y también se pueden utilizar mientras se navega en diferentes sitios al permanecer estáticos.
Indicadores: Los indicadores se encuentran en la parte superior derecha, e indican procesos como la hora, batería, conexión y selector Wi-fi, y conexión 3G.
Pestañas: Las pestañas son lo más utilizado en el sistema, se utilizan para abrir las aplicaciones y sitios, y permiten abrir opciones del sistema. Las pestañas también se pueden "fijar" y disminuir su tamaño para quedar ancladas en la parte superior izquierda.
Lanzadores: Los lanzadores aparecen en la página principal, y son iconos grandes que se utilizan para abrir aplicaciones web, también ver los sitios más visitados, y ver los marcadores en una barra superior.
Velocidad
Uno de los puntos que más destaca Google es la velocidad del sistema, con un tiempo de arranque de 8 segundos y un tiempo apagado bastante pequeño, además de la rapidez que abre sus aplicaciones web.17
Sincronización
Todos los documentos, aplicaciones, extensiones, y configuraciones, son respaldados en línea bajo el concepto de computación en nube. Así que si el usuario pierde su máquina, puede obtener otra o acceder desde otra máquina, y obtener exactamente los mismos datos que mantenía anteriormente.
Siempre conectado
Chrome OS solamente se podrá obtener por medio de la compra directa de un notebook, y cada notebook cuenta con conexión 3G siempre en línea. La promesa de Google es que Chrome OS siempre esté conectado, no importa donde. Además, en las versiones de desarrollo de Chromium OS, ya se están probando las conexiones 4G (LTE) con otros dispositivos.
Aplicaciones Web
Chrome OS no utiliza el típico sistema de aplicaciones, las aplicaciones se utilizan dentro del navegador web Google Chrome, y pueden ser utilizadas en línea o ser instaladas para poder utilizarse sin la necesidad de una conexión a Internet. El principal medio para obtener estas aplicaciones web es la tienda en línea Chrome Web Store, la cual permite adquirir aplicaciones, extensiones y temas para el navegador Google Chrome en un solo lugar. La tienda también permite comprar aplicaciones, y que los desarrolladores publiquen sus aplicaciones basadas en lenguaje web actual.
Seguridad
También contará con una arquitectura de seguridad actualizada. Google enfatiza el hecho de que Chrome no sufrirá de virus o programas maliciosos. Debido a que muchos sistemas operativos actuales fueron diseñados en épocas en las que Internet no era predominante, Chrome se diseña teniendo muy en cuenta esto, por ende eliminando riesgos de seguridad comunes arraigados.
Los puntos más importantes con respecto a la seguridad de Chrome OS son:
Actualizaciones automáticas: Las aplicaciones webs instaladas, extensiones, temas, el navegador, y el sistema operativo se mantendrá al día con actualizaciones automáticas.
Aislamiento de procesos: Aislar procesos que puedan comprometer la seguridad del sistema, tales como Flash Player, extensiones o aplicaciones instaladas.
Verificación de arranque: Monitorea si el sistema ha sido manipulado por entes externos antes de que el sistema parta, y vuelve a una versión de respaldo si esto ha sucedido.
Cifrado de datos: Todos los datos descargados en el disco son cifrados.
Modo visita: Parecido a la cuenta de «invitado» presente en sistemas operativos Windows y GNU/Linux, y al modo Safari en Mac OS X Lion. En este modo el usuario puede pasar la máquina a conocidos para que utilicen una cuenta de visita sin que sus datos se vean comprometidos.
Características avanzadas
Multitáctil
Los primeros gestos multitactiles se vieron en el Chrome Notebook (Cr-48), pero con funcionamientos básicos, como scroll de página con dos dedos. Pero Google dará soporte multitáctil completo de hasta cuatro dedos en versiones estables.
Reproductor multimedia
Todo el contenido multimedia descargado, como música o videos, se podrán reproducir gracias al reproductor multmedia integrado de Chrome OS.
Impresión
Para solucionar el problema de compatibilidad de controladores de hardware de las diferentes impresoras disponibles en el mercado, Google lanza Google Cloud Print (aún en Beta). La cual permite imprimir documentos desde cualquier dispositivo y aplicación, solamente es necesario conectar la impresora a Google Cloud Print y también conectarse mediante Chrome OS para mandar la orden de impresión.25
Chrome OS es un proyecto independiente del sistema operativo Android, el cual fue diseñado principalmente para su uso en teléfonos inteligentes. El nuevo Chrome OS se enfoca hacia usuarios que pasan la mayor parte de su tiempo en Internet, aunque es posible que ambos se fusionen en el futuro al solucionar las diferencias de operación entre Chrome OS y/o Android.
Los Sistemas Operativos, al igual que el Hardware de los computadores, han sufrido una serie de cambios revolucionarios llamados generaciones. En el caso del Hardware, las generaciones han sido marcadas por grandes avances en los componentes utilizados, pasando de válvulas ( primera generación ) a transistores ( segunda generación ), a circuitos integrados ( tercera generación), a circuitos integrados de gran y muy gran escala (cuarta generación). Cada generación Sucesiva de hardware ha ido acompañada de reducciones substanciales en los costos, tamaño, emisión de calor y consumo de energía, y por incrementos notables en velocidad y capacidad.
Generacion Cero (1940)
Los primeros sistemas computacionales no poseían sistemas operativos. Los usuarios tenían completo acceso al lenguaje de la maquina. Todas las instrucciones eran codificadas a mano.
Primera Generacion ( 1950)
Los sistemas operativos de los años cincuenta fueron diseñados para hacer mas fluida la transición entre trabajos. Antes de que los sistemas fueran diseñados, se perdía un tiempo considerable entre la terminación de un trabajo y el inicio del siguiente. Este fue el comienzo de los sistemas de procesamiento por lotes, donde los trabajos se reunían por grupos o lotes. Cuando el trabajo estaba en ejecución, este tenia control total de la maquina. Al terminar cada trabajo, el control era devuelto al sistema operativo, el cual limpiaba y leía e iniciaba el trabajo siguiente.
Se crearon máquinas suficientemente confiables las cuales se instalaban en lugares especialmente acondicionados, aunque sólo las grandes universidades y las grandes corporaciones o bien las oficinas del gobierno se podían dar el lujo de tenerlas.
Para poder correr un trabajo (programa), tenían que escribirlo en papel (en Fortran o en lenguaje ensamblador) y después se perforaría en tarjetas. Enseguida se llevaría la pila de tarjetas al cuarto de introducción al sistema y la entregaría a uno de los operadores. Cuando la computadora terminara el trabajo, un operador se dirigiría a la impresora y desprendería la salida y la llevaría al cuarto de salida, para que la recogiera el programador.
Segunda Generacion (a mitad de 1960)
La característica de los sistemas operativos fue el desarrollo de los sistemas compartidos con multiprogramación, y los principios del multiprocesamiento. En los sistemas de multiprogramación, varios programas de usuario se encuentran al mismo tiempo en el almacenamiento principal, y el procesador se cambia rápidamente de un trabajo a otro. En los sistemas de multiprocesamiento se utilizan varios procesadores en un solo sistema computacional, con la finalidad de incrementar el poder de procesamiento de la maquina.
La independencia de dispositivos aparece después. Un usuario que desea escribir datos en una cinta en sistemas de la primera generación tenia que hacer referencia especifica a una unidad de cinta particular. En la segunda generación, el programa del usuario especificaba tan solo que un archivo iba a ser escrito en una unidad de cinta con cierto numero de pistas y cierta densidad.
Se desarrollo sistemas compartidos, en la que los usuarios podían acoplarse directamente con el computador a través de terminales. Surgieron sistemas de tiempo real, en que los computadores fueron utilizados en el control de procesos industriales. Los sistemas de tiempo real se caracterizan por proveer una respuesta inmediata.
Tercera Generacion (mitad de 1960 y de 1970)
Se inicia en 1964, con la introducción de la familia de computadores Sistema/360 de IBM. Los computadores de esta generación fueron diseñados como sistemas para usos generales . Casi siempre eran sistemas grandes, voluminosos, con el propósito de serlo todo para toda la gente. Eran sistemas de modos múltiples, algunos de ellos soportaban simultáneamente procesos por lotes, tiempo compartido, procesamiento de tiempo real y multiprocesamiento. Eran grandes y costosos, nunca antes se había construido algo similar, y muchos de los esfuerzos de desarrollo terminaron muy por arriba del presupuesto y mucho después de lo que el planificador marcaba como fecha de terminación.
Estos sistemas introdujeron mayor complejidad a los ambientes computacionales; una complejidad a la cual, en un principio, no estaban acostumbrados los usuarios.
Cuarta Generacion (mitad de 1970 en adelante)
En la cuarta generación la electrónica avanza hacia la integración a gran escala, pudiendo crear circuitos con miles de transistores en un centímetro cuadrado de silicón y ya es posible hablar de las computadoras personales y las estaciones de trabajo. Surgen los conceptos de interfaces amigables intentando así atraer al público en general al uso de las computadoras como herramientas cotidianas. Se hacen populares el MS-DOS y UNIX en estas máquinas. También es común encontrar clones de computadoras personales y una multitud de empresas pequeñas ensamblándolas por todo el mundo.
Para mediados de los 80's, comienza el auge de las redes de computadoras y la necesidad de sistemas operativos en red y sistemas operativos distribuidos. La red mundial Internet se va haciendo accesible a toda clase de instituciones y se comienzan a dar muchas soluciones ( y problemas ) al querer hacer convivir recursos residentes en computadoras con sistemas operativos diferentes. Para los 90's el paradigma de la programación orientada a objetos cobra auge, así como el manejo de objetos desde los sistemas operativos. Las aplicaciones intentan crearse para ser ejecutadas en una plataforma específica y poder ver sus resultados en la pantalla o monitor de otra diferente (por ejemplo, ejecutar una simulación en una máquina con UNIX y ver los resultados en otra con DOS ). Los niveles de interacción se van haciendo cada vez más profundos.
