PRACTICAS 1-15

Practica 1 Matando un proceso en modo grafico

Practica 2 Matando un proceso por línea de comandos

Practica 3 Matando un proceso por medio de scripts

Practica 4 Ver los procesos de usuario desde línea de comandos

Practica 5 Mostrando los porcentajes de uso de memoria de los procesos

Practica  6 Ejecución de procesos de manera concurrente

Prac7 Uso del comando jobs (viendo estado de procesos)

Practica 8 Pausar tareas y 9 Muestra de reinicio de procesos

Practica 10 Crear una lista FIFO

Practica 11 Agregando un proceso a una lista FIFO

Practica 12 Creado listas con mknod

PRACTICA 13 Observar listas de procesos creadas hasta ahora

PRACTICA 14  Eliminando una lista

Practica 15 Ver árbol de procesos

LIFO Y FIFO

FIFO
(primero en llegar primero en salir)

se utiliza en estructuras de datos para implementar colas. La implementación puede efectuarse con ayuda de arrays o vectores, o bien mediante el uso de punteros yasignación dinámica de memoria.

Si se implementa mediante vectores el número máximo de elementos que puede almacenar está limitado al que se haya establecido en el código del programa antes de la compilación (cola estática) o durante su ejecución (cola pseudoestática ó dinámica). Sea cual sea la opción elegida, el número de elementos que podrá almacenar la cola quedará determinado durante toda la ejecución del programa. Así, el sistema debe reservar el tamaño de memoria necesario para acoger todos los datos, sea cual sea el número de elementos usados.

En algunas aplicaciones, esto supone un problema ya que puede desconocerse el número de elementos a contener en la cola. La sencilla solución de reservar más memoria de la que se supone que se necesitará, puede conducir a un despilfarro de la memoria (la cola puede esté llena, aprovechando toda la memoria reservada; o bien, nunca terminar de llenarse, ocupando recursos innecesarios en memoria). Sin embargo, si se usa asignación dinámica de memoria, el número máximo no está declarado en tiempo de compilación sino en tiempo de ejecución, es decir, se reserva memoria a medida que se necesite expandir el tamaño de la cola (adaptándose al tamaño necesario en cada momento en función de los elementos que hay en la cola), haciendo un mejor uso de la memoria disponible.

Uno de los usos de las colas es la exploración "en anchura" de un árbol binario de búsqueda. Otro uso típico de las colas, es la gestión de descargas de una aplicación P2P.

LIFO

estructura  LIFO  (ultimo en entrar primero en salir).

Podemos comparar esta estructura con una pila de platos colocada sobre un muelle. Cuando

se añade un nuevo plato en lo alto de la pila, los demás bajan, cuando se retira un plato de la pila,

los demás suben.igual que en el caso de las colas, van a existir dos punteros, uno que indica la posición tope

de la pila, denominado puntero de pila, y otro que señala su base, denominado  base de pila,   y que mantiene el mismo valor mientras existe la pila. Cuando la pila esta vacía el puntero de pila tiene el mismo valor que la base de pila.

La pila es una de las estructuras más importantes en computación. Se usa en cálculos, para

pasar de un lenguaje de computador a otro y, para transferir el control de una parte del programa

a otra.

EXAMEN

#include "rshmem.h"
#include <stdlib.h>
#include <sys/sem.h>
#include <math.h>
#include <time.h>
#define N 5 
typedef int semaphore;                                                    
int state[N];                                                             
semaphore mutex=1;                                                        
semaphore s[N];                                                           
viod philosopher(int i)                                                   
{
 incrementa (int *mem, int k){
int i;
i=*mem;
TP ; TP ; TP TP ;
TP ; TP TP ; TP ;
TP TP ; TP ; TP
i=i+k;
TP ; TP ; TP TP ;
TP ; TP TP ; TP ;
TP TP ; TP ; TP
*mem=i;

 }

filosofo(FILE *pf, key_t *sclave, int *sfilo, int i, int *comer, int *fin, int *fc){
while (true){                                                             
think();                                                                  
take_forks(i);                                                            
eat();                                                                    
put_forks(i);                                                             
}
}
void take_forks(int i)                                                    
{
down(&mutex);                                                             
state[i] = HUNGRY;                                                        
test(i);                                                                  
up(&mutex);                                                               
down(&s[i]);                                                              
}                                                                                   
void put_forks(i)                                                         
{                               
down(&mutex);                                                             
state[i] = THINKING;                                                      
test(LEFT);                                                               
test(RIGHT);                                                              
up(&mutex);                                                               
}
void test(i)                                                              
{
if(state[i] == HUNGRY && state [LEFT]!= EATING && state [RIGHT]!=EATING){
state[i]=EATING;
up(&s[i]);
}
}