Mensajes

Buenas a todos, resulta que viendo un poco sobre la API de UNIX y la API de WINDOWS observe que la creación de UNIX de proceso se hacia en dos pasos:
1. Llamada del sistema fork. Creación de un clon del proceso padre.
2. Llamada del sistema exec. Cambiar la imagen del proceso por un nuevo programa.

Mientras que este mismo proceso WINDOWS lo hacia en unicamente una llamada al sistema. En unos de los textos se mencionaba que el hecho de que se hiciera en dos pasos daba la posibilidad de tener un punto intermedio que permitia el compartir datos entre padre-hijo pero no termino de comprender que tanto impacto puede tener esto.

¿ Hay alguna cosa que no sea posible hacer en Windows debido a que esta situacion ?
¿ Qué ejemplo practico o real podria hacer uso de esta ventaja o se podria considerar más como una desventaja por parte de UNIX ?

[1.]

Durante la observacion de los resultados originados por el comando 'ps', observe que habia dos casos particulares que generan incognitas en cuanto a lo que implicaban:

1. Procesos que que tenian el STAT S. S Interruptible sleep (waiting for an event to complete)
Era generado cuando dentro de un proceso utilizaba el metodo SLEEP correspondiente a la SIGALRM.Sin embargo me surge la duda de que es lo que ocurre, el proceso es retirado de la cola de procesos listos para finalmente ser activado por el SO mediante una senal cuando su tiempo de 'dormir' ha sido completado? o permanece en la cola de procesos listos y cada vez que le toca una RAFAGA DE CPU verifica si su tiempo de 'dormir' ha terminado?

2. T Procesos que que tenian el STAT T . T Stopped, either by a job control signal or because it is being traced.
Generado mientras terminaba un proceso con CTRL + Z. correspondiente a la senal SIGTSTP que al buscar sobre ella me di cuenta que podia ser ignorada por el proceso y que simplemente lo manda a este estado sin matarlo. Esto que consecuencias puede tener? he visto que mediante el comando 'top' el proceso no aparece pero entonces me hace creer que minimamente es retirado de la cola de proceso listos pero sin embargo que incoveniente puede tener el tenerlo en este estado? Simplemente mayor consumo de memoria para guardar el registro de dicho proceso? o  acaso tampoco se liberan los recursos ocupados por dicho proceso


NOTA. Una disculpa por subir la entrada incompleta, se me cerro accidentalmente el navegador y se subio el tema incompleto al principio

Muchas gracias a todos por su respuesta. Me parece que seguire leyendo para hilar todas estos conceptos e ir construyendo poco a poco todo.

Es un tema complejo, y realmente se utilizan hilos como unidades de ejecucción. Dime que es lo que realmente buscas y podré pasarte papers sobre el tema.

Inicialmente mi pregunta es si en la actualidad tenia alguna utilidad evidente el utilizar la creacion de procesos a traves de llamados al sistema como fork,exec,etc.. Creo que esta respuesta la ire obteniendo conforme vaya poniendo en practica estos conceptos en algun programa que es lo que actualmente estoy haciendo.

Como segunda pregunta tenia una duda con referencia a la planifcacion en sistemas con procesadores multiples para lo cual voy a escribir un segmento del libro donde lei sobre el tema

Si se dispone de multiples CPU, el problema de planifacion , es complejo...........................
Algunos sistemas estra estructura un paso mas alla, haciendo que todas las decisiones de planifacion,el procesamiento de E/S y otras actividades del sistema sean maneajdas por un solo procesador-el servidor maestro.Los otros procesadores solo ejecutan codigo de usuario.este multiprocesamineto asimetrico es mucho mas sencillo al simetrico.............

Cita obtenida del Libro de Sistemas Operativos 6a. Edicion, Silberschatz Galvin Gagne. Pag. 153

Aqui es donde me surge una duda.. Esta explicacion es clara cuando los procesos que se trabajan son de un solo hilo..Pero cuando se ingresa un proceso con varios hilos como es que se procesa?. Solamente se le asigna finalmente un nucleo a ese proceso y no permite que cada hilo se procese en distintos nucleos en paralelo o les qutia la carga de trabajo a una parte de los nucleos y les asigna como trabajo un hilo mientras se encuentra en CPU el proceso que lo requiere, cuando se le acaba la rafaga todo vendria a volver a la normalidad. Y finalmente intuyo que estos conceptos son muy teoricos y que por lo general en la practica no se ve la estructura como tal , sino una combinacion de varias formas de hacerlo pero que tan cercana es la situacion en LINUX, es decir, en LINUX se toma un enfoque de planificacion con varios multiprocesadores o simplemente se utiliza 1 para esta tarea y cuando un proceso demanda varios hilos se activan los demas nucleos?.

Se que tal vez son dudas un poco tontas pero he empezado hace unas pocas semanas con el tema y me he topado con mucha informacion pero con poca practica donde pueda reforzar la teoria. Actualmente estoy leyendo el libro Silberschatz y hace unos dias comence con el libro de Interprocess Communications in Linux de John Shapley Gray que me parece que es un libro con mas practicas.

Para efectos de planificación, hasta donde yo tengo entendido, los procesos y threads son indistinguibles. No veo porque no se puedan paralelizar multiples procesos de un solo thread.

En esta parte tal vez no me explique muy bien. Quisiera hacer referencia al planificador como tal, por ejemplo:
El planificador tiene un 'X' algoritmo pero resulta que utiliza todos los procesadores para distribuir los diversos procesos en la cola de lista entre los diversos nucleos. Para ser mas concreto podria ser que existieran 4 nucleos:
1 Nucleo. Es el nucleo maestro, es el unico que tiene acceso a la cola de procesos listos y le asigna a cada uno de los otros 3 nucleos un conjunto de esos procesos listos.
2,3,4 Nucleo. Solo ejecutan procesos que le son pasados por el nucleo maestro.

En este caso o en algoritmos donde se haga uso de todos los nucleos para la planificacion de una forma parecida que succede si entra un proceso que tiene 4 hilos en paralelo en un mismo instante de tiempo?. Supongamos que este proceso estaba destinado para estar en el nucleo 2 pero esta requiriendo hilos a nivel de kernel. En ese caso cambia todo el algoritmo de planificacion para que ahora 2 procesos se queden despachando procesos y los otros dos nucleos intenten satisfacer los hilos de dicho proceso o simplemente es rechazada su paralelismo y se le asigna un unico nucleo para todos sus hilos. Aclarando que ese cambio va ser solo una porcion de segundo(quantum). O definitivamente no se usa este tipo de estructura para sistemas operativos que permiten el paralelismo en hilos/procesos.

Entonces al parecer cuando se habla de paralelismo la opcion mas viable siempre es la de los hilos pero que razon de ser pueden tener la creacion de procesos a partir de un padre?. He visto un poco las funciones fork,wait,exec,etc.. Y comprendo que la generacion de un nuevo proceso permite crear esa jerarquia de hijos-padre pero realmente hasta ese punto aun no se esta hablando sobre paralelismo, verdad?. Entonces que sentido tendria crear varios procesos de esta manera que pudiera presentar una ventaja conforme a los hilos. O este proceso es heredado por codigo que fue desarrollado desde antes de la existencia de hilos y ya solo es visto como contenido educativo?.

Como un punto y aparte me surge la duda de si el planificador de procesos de corto plazo de linux hace uso de los varios nucleos disponibles en la computadora. He visto varios puntos de vista en donde algunos hablan de la insercion de los PCB en arboles ordenados conforme a su tiempo en CPU que se les ha dado, mientras que algunos otros lados se enfocan mas en explicar que se trata de un mapa de bits con cada prioidad en donde cada posicion se encuentra almacenados los procesos con dicha prioridad pero mi principal duda surge en el momento de que se usan los distintos nucleos para la parte de la planificacion, he leido sobre el hecho de que esto puede ser implementado de distintas maneras como por ejemplo a traves de un nucleo maestro,etc. Pero en Linux se implementa esta forma de utilizar varios nucleos en la planifacion? y en dado caso que llega a pasar cuando el planificador funciona con varios nucleos y llega un proceso que tiene varios hilos y requiere paralelismo?. Se comparten los nucleos entre el planificador y ese nuevo proceso con hilos o se le da todos los nucleos momentaneamente al proceso con varios hilos?

Buenas a todos, actualmente estoy revisando el libro de Sistemas Operativos , Silberschatz Galvin Gagne y me ha surgido una duda con referencia al uso que se le pueden dar tanto a los procesos como a los hilos. Entiendo el concepto tanto de hilos y procesos sin embargo no llego a entender la finalidad de poder crear varios procesos. Tal vez suene un poco tonto pero no he encontrado un ejemplo claro en donde vea una ventaja o necesidad de crear varios procesos dentro de una misma computadora y crear una linea de comunicacion entre ellos a la contraparte de generar hilos.

En el libro se enfoca mucho en el hecho de que los hilos son mas rapidos de construir en el sentido de que se encuentran dentro de un mismo proceso y pueden compartir facilmente informacion. Ademas se explica un poco como es posible sacarle provecho para que cada hilo pueda ser ejecutado por un nucleo distinto y que cada uno tenga una actividad especifica dentro del programa. Este concepto de poder utilizar varios nucleos y ejecutar varios hilos en paralelo con ayuda de varios nucleos es posible tambien con los procesos?, he leido que en linux todo (hilo,procesos) es tomado como proceso pero el mismo concepto se ve reflejado en sistemas de windows?.

Finalmente me gustaria saber  si alguien me podria proporcionar un ejemplo claro en el que es util tener varios procesos en paralelo en contraparte de por que no se podria hacer con hilos?. Me gustaria tener alguna referencia o guia que trate estos temas de una manera mas practica a traves del lenguaje C/C++ para reforzar la teoria, si alguien conoce alguna se lo agradeceria de antemano.

Buenas a todos. He estado viendo los diversos algoritmos de planificacion de procesos y he visto que algunos como el 'shortest job first' hacen uso del tiempo de rafa de CPU requerido por cada procesos para ordenarlos en una cola sin embargo mi pregunta es sobre ¿ como y en que momento se determina el tiempo de rafaga de CPU?. En simuladores entiendo que el tiempo es inventado y se simula la construccion de PCB's pero como determina el algoritmo real ¿ cual es el tiempo de rafaga de CPU necesario para cada proceso?. ¿ Acaso tiene una tabla de equivalencia para cada instruccion posible y hace el calculo conforme al codigo por ejecutar de dicho proceso?

En su mayoria si, solo me falta agregar algunas cosas sobre la base de datos pero seria solo agregar llamados a metodos dentro de esas clases "Directorios". Estaba pensando usar el patron de diseño DAO y DTO que hasta donde he visto es practicamente hacer una clase DAO por cada clase DTO que sea la que haga las consultas relacionadas con esa clase a la base de datos.

Esta solo es una parte del problema principal pero el otro segmento del problema ya lo tengo diseñado y en su mayoría ya esta pasado a código.

Interfaz.

Código (java) [Seleccionar] Expandir


import java.util.Vector;

public interface Directorio {
   public boolean eliminarContacto(Contacto c);
   public boolean agregarContacto(Contacto c)throws IllegalArgumentException;
   public boolean modificarContacto(int id,Contacto c)throws IllegalArgumentException;
   public Vector<Contacto> getContactos();
}



Clase Directorio Personal.

Código (java) [Seleccionar] Expandir


import java.util.Iterator;
import java.util.Vector;

public class DirectorioPersonal implements Directorio {
   
   Vector<ContactoPersonal> contactos;
   
   public DirectorioPersonal(){
       contactos = new Vector<>();
   }
   
   @Override
   public boolean eliminarContacto(Contacto c){
       /*Hace polimorfismo con el metodo equals . No hay problema */
       
       return contactos.remove(c);
   }
   
   @Override  
   public boolean agregarContacto(Contacto c)throws IllegalArgumentException{
       if(!(c instanceof ContactoPersonal))
           throw new IllegalArgumentException();
        return contactos.add((ContactoPersonal)c);
   }
   
   
   
   @Override
   public Vector<Contacto> getContactos(){
       Vector<Contacto> lista = new Vector<>();
       Iterator itr1 = contactos.iterator();
       while(itr1.hasNext()){
           lista.add((Contacto)itr1.next());
       }
       return lista;
   }
   
   @Override
   public boolean modificarContacto(int id,Contacto c)throws IllegalArgumentException{
       if(!(c instanceof ContactoPersonal))
           throw new IllegalArgumentException();
       
       Contacto contacto = getContacto(id);
       if( contacto == null)
            return false;
//Polimorfismo en metodo swap
       contacto.swap(c);
       return true;
   }
   
/*Metodo auxiliar para modificar contacto */
   private Contacto getContacto(int id){
       Iterator itr = contactos.iterator();
       ContactoPersonal aux = null;
       
       while(itr.hasNext()){
           aux = (ContactoPersonal)itr.next();
           if(aux.getId() == id)
               return aux;
       }
       
       return null;
   }
}