Re: AGP.

[Darlock <darlock@teleline.es>]

On Thu, 20 Jul 2000, Ricardo Adolfo Rodríguez wrote:

      Holas a todos.
      
      Tengo una tarjeta de video Trident 970 AGP 4MB.
      
En esto no te puedo ayudar, ya que no se nada del tema este de AGP, pero
segun mi humilde e inexperta opinion diria que es lo mismo a nivel de las
X una tarjeta PCI que una AGP, pero ya te digo, no tengo ni idea...

      Pero no se si sea un offtopic... pero me voy a arriesgar.. hace unos dos
      meses empeze con la tarea de aprender a programar en linux :), voy en la
      parte de comunicacion entre procesos.. pipes, que es la primera parte...
      pero como estoy tan principiante hay algo que no entiendo... (perdonen
      si es muy obvio..), y la verdad donde vivo... no tengo mucho a quien
      preguntarle... y el acceso a internet en este momento lo tengo difícil..

No problemo, si te podemos servir de ayuda, pues yata, que aunque esto sea
una 'comunidad Debian' tambien programamos de vez en cuando algunos... ;-)      
      
      
La idea del codigo este me recuerda a mis clases de Introduccion a los
Sistemas Operativos, pero te falta la parte anterior del codigo, que
tendria que ser un fork... o sea que supondremos esto...

El funcionamiento es el siguiente: El proceso que se enciende tiene un
pid, que es un numero que cuando se enciende la maquina se pone a cero y
que por cada proceso creado se incrementa, a partir del proceso principal,
o padre, se hace una llamada a fork, que lo que hace es crear un hijo,
retornando (Y ESTO ES LO IMPORTANTE) un 0 para el proceso hijo y el pid
del hijo para el padre, o sea que si se hace una linea:

	childpid= fork();

El padre contendra en su variable childpid el pid del hijo, y el hijo no
tendra su pid, sino un cero, asi se puede diferenciar uno del otro en el
resto del codigo... lo que se hace en tu codigo es decir: si es el hijo,
entonces cierro la entrada estandard (la tabla de descriptores de ficheros
se copia en la ejecucion del fork), y despues escribe en la salida
estandard un mensaje y sale; el padre cierra SU salida, y escucha de SU
entrada (cada proceso tiene su propia tabla, como he dicho antes), por
tanto se supone que antes de hacer la llamada fork, se han cerrado la
entrada y la salidas estandards y se ha creado por ejemplo una pipe, con
lectura en el fd[0] y escritura en el fd[1].   

La verdad es que es un poco liado, pero es bonito de ver (creo yo), o sea
que si tienes alguna otra duda (y soy capaz de responder) ya sabes, emilio
al canto... ;-)

                if(childpid  ==  0)
                {
                          /*  Cierre  del  descriptor  de  entrada  en  el
      hijo  */
                          close(fd[0]);
      
                          /*  Enviar  el  saludo  via  descriptor  de  salida
      */
                          write(fd[1],  string,  strlen(string));
                          exit(0);
                }
                else
                {
                          /*  ¿Esto no cerraria el descriptor de salida del
      hijo?  */
                          close(fd[1]);
      
                          /*  ¿Y aqui no pasaria algo similar? osea estaria
      cerrado el descriptor de entrada por el close(fd[0])? */
                          nbytes  =  read(fd[0],  readbuffer,
      sizeof(readbuffer));
                          printf("Received  string:  %s",  readbuffer);
                }
      
Espero que te vaya bien tu iniciacion al mundo de la programacion Linux...      

______________________________________________________
Josep Llauradó Selvas	           darlock@teleline.es
	         Linux Registered User #153481
The only "intuitive" interface is the nipple.
After that, it's all learned.
(in comp.os.linux.misc, on X interfaces.)
FP: 199E 7539 13B7 AA30 0B0C  263E 5991 03A7 625F B24F
______________________________________________________