Practicas matando proceso

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

Practica15

Practica 15 Ver árbol de procesos

practica semaforos

lock_lp (tipo_flag flag)
{
BOOL entrar= 0;
while (!entrar) {
lock(cerrojo_flags);
if (flag) {
unlock(cerrojo_flags);
dormir(flag);
}
else {
entrar= 1;
flag= 1;
unlock(cerrojo_flags);
}
}
}
unlock_lp (tipo_flag flag)
{
lock(cerrojo_flags);
flag= 0;
despertar(flag);
unlock(cerrojo_flags);
}

a) Analizar la estructura de las secciones criticas que contiene.
El código es de acceso exclusivo y se protege con una sección crítica de corto plazo mediante un cerrojo de exclusión mutua único común, que llamamos (de mutual exclusión). Pero un proceso no puede quedarse dormido dentro de la sección crítica de corto plazo en lock_lp, ya que no permitiría la ejecución de despertar por otro proceso.
b) Siguiendo esta misma idea, dados los algoritmos de bajar y subir sobre semáforos.
Subir () puede encargarse de liberar los cerrojos de los procesos, y bajar() de restaurarlos. En otras palabras, los procesos en estado bloqueado se consideran fuera de toda sección crítica. Un problema del esquema subir/bajar es que bajar desbloquea a todos los procesos subidos en el flag y sólo uno de ellos accederá a la sección crítica. Esto es especialmente preocupante en multiprocesadores, ya que producirían contención en el acceso al cerrojo. Sin embargo, la limitación fundamental del manejo de eventos con este mecanismo deriva de que la primitiva de bajar no almacena el evento; lo que introduce la posibilidad de condiciones de carrera en una secuencia de subir y bajar sobre un flag (importa el orden en que se ejecutan).

FIFO Y LIFO

FIFO: Guarda analogía con las personas que esperan en una cola y van siendo atendidas en el orden en que llegaron, es decir, que la primera persona que entra es la primera persona que sale.

También se lo llama first come first served o FCFS (en español "primero en llegar, primero en ser atendido").



En hardware, un FIFO se usa para propósitos de sincronización. Comportándose como una cola circular y, por lo tanto, contiene dos punteros:

1.Puntero de Lectura / Registro de Dirección de Lectura
2.Puntero de Escritura / Registro de Dirección de Escritura
Las direcciones de lectura y escritura están ambas inicialmente en la primera ubicación de la memoria y la cola FIFO está Vacía.

FIFO Vacía
Cuando el registro de dirección de lectura alcanza al registro de dirección de escritura, la cola FIFO dispara la señal o bandera Vacío.
FIFO Llena
Cuando el registro de dirección de escritura alcanza al registro de dirección de lectura, la cola FIFO dispara la señal o bandera

LIFO

El término LIFO es el acrónimo inglés de Last In First Out (último en entrar, primero en salir). elementos almacenados en forma de algunos tipos de estructuras de datos se procesan. Por definición, en una lista estructurada LIFO lineales, los elementos pueden ser añadidos o retirados de un solo extremo, llamado el "top". [1] Una estructura LIFO se puede ilustrar con el ejemplo de una pila de bandejas. La última bandeja para ser colocado en la parte superior es también el primero en tomar la parte superior.

Examen

#include "rshmem.h"
#include
#include
#include
#include
#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]);
}
}