Changes between Version 23 and Version 24 of WikiStart

Timestamp:

Mar 26, 2009, 1:44:24 PM (16 years ago)

Author:

Mattia Monga

Comment:

--

WikiStart

@@ -355 +355 @@
 
 
-=== Esercizi online (per turno 2) ===
+=== Esercizi online con la shell ===
  * [http://idea.sec.dico.unimi.it/~lorenzo/SisOp0809/ Esercizi online]
+
+== Lezione 4 ==
+
+=== Slide ===
+
+ * '''Turno 1 (25 Marzo 2009)''': [http://homes.dico.unimi.it/sisop/lucidi0809/solab04.pdf slide] ([http://homes.dico.unimi.it/sisop/lucidi0809/solab04-handout.pdf Versione stampa])
+
+=== Programmi ===
+
+==== Esempi con la syscall `clone`, specifica di Linux ==== 
+
+ * Thread '''senza''' memoria condivisa  `threads-isolated.c`
+ 
+{{{
+#!c
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sched.h>
+
+int run(void* s)
+{
+        int* shared = (int*)s; /* alias per comodita` */
+        while (shared[0] < 10) {
+                sleep(1);
+                printf("Processo figlio (%d). s = %d\n", 
+                       getpid(), shared[0]);
+                if (!(shared[0] < 10)){
+                        printf("Corsa critica!!!!\n");
+                        abort();
+                }
+                shared[0] += 1;
+        }
+        return 0;
+}
+
+
+int main(void){
+ 
+        int shared[2] = {0 , 0};
+
+        /* int clone(int (*fn)(void *), 
+         *           void *child_stack, 
+         *           int flags,
+         *           void *arg); 
+         * crea una copia del chiamante (con le caratteristiche 
+         * specificate da flags) e lo esegue partendo da fn */
+        if (clone(run, /* il nuovo
+                        * processo esegue run(shared), vedi quarto
+                        * parametro */
+                  malloc(4096)+4096,  /* lo stack del nuovo processo 
+                                       *  (cresce verso il basso!) */
+                  SIGCHLD, /* in questo caso la clone e` analoga alla fork */
+                  shared) < 0){
+                perror("Errore nella creazione");
+                exit(1);
+        } 
+
+        if (clone(run, malloc(4096)+4096,  SIGCHLD, shared) < 0){
+                perror("Errore nella creazione");
+                exit(1);
+        } 
+
+        /* Isolati: ciascuno dei figli esegue 10 volte. Per il padre
+         * shared[0] e` sempre 0 */
+
+        while(1) {
+                sleep(1);
+                printf("Processo padre. s = %d\n", shared[0]);
+        }
+        return 0;
+}
+}}}
+
+ * Thread '''con''' memoria condivisa `threads-shared.c`
+
+{{{
+#!c
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sched.h>
+
+int run(void* s)
+{
+        int* shared = (int*)s; /* alias per comodita` */
+        while (shared[0] < 10) {
+                sleep(1);
+                printf("Processo figlio (%d). s = %d\n", 
+                       getpid(), shared[0]);
+                if (!(shared[0] < 10)){
+                        printf("Corsa critica!!!!\n");
+                        abort();
+                }
+                shared[0] += 1;
+        }
+        return 0;
+}
+
+
+int main(void){
+ 
+        int shared[2] = {0 , 0};
+
+        /* int clone(int (*fn)(void *), 
+         *           void *child_stack, 
+         *           int flags,
+         *           void *arg); 
+         * crea una copia del chiamante (con le caratteristiche 
+         * specificate da flags) e lo esegue partendo da fn */
+        if (clone(run, /* il nuovo
+                        * processo esegue run(shared), vedi quarto
+                        * parametro */
+                  malloc(4096)+4096,  /* lo stack del nuovo processo 
+                                       *  (cresce verso il basso!) */
+                  CLONE_VM | SIGCHLD, /* la (virtual) memory e` condivisa */
+                  shared) < 0){
+                perror("Errore nella creazione");
+                exit(1);
+        } 
+
+        if (clone(run, malloc(4096)+4096,  CLONE_VM | SIGCHLD, shared) < 0){
+                perror("Errore nella creazione");
+                exit(1);
+        } 
+
+        /* Memoria condivisa: i due figli nell'insieme eseguono 10 o
+         * 11 volte: e` possibile una corsa critica. Il padre
+         * condivide shared[0] con i figli */
+
+        while(1) {
+                sleep(1);
+                printf("Processo padre. s = %d\n", shared[0]);
+        }
+        return 0;
+}
+}}}
+
+ * Thread '''con''' memoria condivisa, mutua esclusione ottenuta con Peterson `threads-peterson.c` 
+
+{{{
+#!c#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sched.h>
+
+
+void enter_section(int process, int* turn, int* interested)
+{
+        int other = 1 - process;
+        interested[process] = 1;
+        *turn = process;
+        while  (*turn == process && interested[other]){ 
+                printf("Busy waiting di %d\n", process);
+        }
+}
+
+void leave_section(int process, int* interested)
+{
+        interested[process] = 0;
+}
+
+int run(const int p, void* s)
+{
+        int* shared = (int*)s; /* alias per comodita` */
+        while (enter_section(p, &shared[1], &shared[2]), 
+               shared[0] < 10) {
+                sleep(1);
+                printf("Processo figlio (%d). s = %d\n", 
+                       getpid(), shared[0]);
+                if (!(shared[0] < 10)){
+                        printf("Corsa critica!!!!\n");
+                        abort();
+                }
+                shared[0] += 1;
+                leave_section(p, &shared[2]);
+        }
+        return 0;
+}
+}}}
+
+ * Thread '''con''' memoria condivisa, mutua esclusione con TSL `threads-tsl.c`, `enter.asm`
+
+{{{
+#!c
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <signal.h>
+#include <sched.h>
+
+
+void enter_section(int *s); /* in enter.asm */
+
+void leave_section(int *s){
+        *s = 0;
+}
+
+int run(const int p, void* s)
+{
+        int* shared = (int*)s; /* alias per comodita` */
+        while (enter_section(&shared[1]), 
+               shared[0] < 10) {
+                sleep(rand() % 3);
+                printf("Processo figlio (%d). s = %d\n", 
+                       getpid(), shared[0]);
+                if (!(shared[0] < 10)){
+                        printf("Corsa critica!!!!\n");
+                        abort();
+                }
+                shared[0] += 1;
+                leave_section(&shared[1]);
+        }
+        return 0;
+}
+
+int run0(void*s){ return run(0, s); }
+int run1(void*s){ return run(1, s); }
+        
+
+int main(void){
+ 
+        int shared[4] = {0 , 0, 0, 0};
+
+        /* int clone(int (*fn)(void *), 
+         *           void *child_stack, 
+         *           int flags,
+         *           void *arg); 
+         * crea una copia del chiamante (con le caratteristiche 
+         * specificate da flags) e lo esegue partendo da fn */
+        if (clone(run0, /* il nuovo
+                         * processo esegue run(shared), vedi quarto
+                         * parametro */
+                  malloc(4096)+4096,  /* lo stack del nuovo processo 
+                                       *  (cresce verso il basso!) */
+                  CLONE_VM | SIGCHLD, /* la (virtual) memory e` condivisa */
+                  shared) < 0){
+                perror("Errore nella creazione");
+                exit(1);
+        } 
+
+        if (clone(run1, malloc(4096)+4096,  CLONE_VM | SIGCHLD, shared) < 0){
+                perror("Errore nella creazione");
+                exit(1);
+        } 
+
+        /* Memoria condivisa: i due figli nell'insieme eseguono 10 o
+         * 11 volte: e` possibile una corsa critica. Il padre
+         * condivide shared[0] con i figli */
+
+        while(shared[0] < 10) {
+                sleep(1);
+                printf("Processo padre. s = %d %d %d %d\n", 
+                       shared[0],
+                       shared[1],
+                       shared[2],
+                       shared[3]);
+        }
+        return 0;
+}
+}}}
+
+{{{
+section .text
+global enter_section
+
+enter_section:
+        enter 0, 0         ; 0 bytes of local stack space
+        mov   ebx,[ebp+8]     ; first parameter to function
+
+spin:   lock bts dword [ebx], 0
+        jc spin
+
+        leave                   ; mov esp,ebp / pop ebp
+        ret     
+}}}
+
+{{{
+#!sh
+nasm -felf enter.asm
+cc threads-tsl.c enter.o -o threads-tsl
+}}}
+
+==== Esempi in Java ====
+
+ * Creazione di thread `Basic.java`
+
+{{{
+#!java
+class ClasseAttiva extends Thread{
+    public void run(){
+        while (true) {
+            try {
+                Thread.sleep(100);
+            }
+            catch(InterruptedException e){
+                System.err.println(e);
+            }
+            System.out.println(this.getName());
+        }
+    }
+}
+
+public class Basic {
+    public static final void main(final String[] args) {
+        ClasseAttiva o1 = new ClasseAttiva();
+        ClasseAttiva o2 = new ClasseAttiva();
+        o1.start();
+        o2.start();
+        while (true){
+            try {
+                Thread.sleep(100);
+            }
+            catch(InterruptedException e){
+                System.err.println(e);
+            }
+
+            System.out.println("Main thread");
+        }
+        
+    }
+}
+}}}
+
+ * Memoria condivisa `Shared.java`
+
+{{{
+#!java
+
+class ClasseAttiva extends Thread{
+    protected static int shared = 0;
+    public void run() {
+        while (true) {
+            if (shared >= 10) break;
+            try {
+                Thread.sleep(1000);
+            }
+            catch(InterruptedException e){
+                System.err.println(e);
+            }
+            if (shared >= 10){
+                throw new Error("Corsa critica!!!");
+            }
+            System.out.println(this.getName() + " s = " + shared);
+            shared += 1;
+        }
+    }
+}
+
+
+
+public class Shared {
+    public static final void main(final String[] args) {
+        ClasseAttiva o1 = new ClasseAttiva();
+        ClasseAttiva o2 = new ClasseAttiva();
+        o1.start();
+        o2.start();
+        while (true){
+            try {
+                Thread.sleep(1000);
+            }
+            catch(InterruptedException e){
+                System.err.println(e);
+            }
+
+            System.out.println("Main thread");
+        }
+        
+    }
+}
+}}}
+
+ * Memoria condivisa, mutua esclusione ottenuta con `synchronized`, `Shared2.java`
+
+{{{
+#!java
+class ClasseAttiva extends Thread{
+    protected static int shared = 0;
+    protected static Object lock = new Object();
+    public void run() {
+        while (true) {
+            synchronized(lock){
+                if (shared >= 10) break;
+                try {
+                    Thread.sleep(1000);
+                }
+                catch(InterruptedException e){
+                    System.err.println(e);
+                }
+                if (shared >= 10){
+                    throw new Error("Corsa critica!!!");
+                }
+                System.out.println(this.getName() + " s = " + shared);
+                shared += 1;
+            }
+            Thread.yield(); // non necessaria, ma favorisce lo scheduling di entrambi
+        }
+    }
+}
+
+
+
+public class Shared2 {
+    public static final void main(final String[] args) {
+        ClasseAttiva o1 = new ClasseAttiva();
+        ClasseAttiva o2 = new ClasseAttiva();
+        o1.start();
+        o2.start();
+        while (true){
+            try {
+                Thread.sleep(1000);
+            }
+            catch(InterruptedException e){
+                System.err.println(e);
+            }
+
+            System.out.println("Main thread");
+        }
+        
+    }
+}
+}}}
+
+ * Produttore e consumatore 
+
+{{{
+#!java
+
+class Actor extends Thread 
+{
+    public Actor(String nome){
+        super(nome);
+    }
+    
+    private Magazzino shared;
+    public final Magazzino getShared() {
+        return shared;
+    }
+    public final void setShared(final Magazzino newShared) {
+        this.shared = newShared;
+    }
+
+}
+
+
+class Produttore extends Actor {
+    public Produttore(String nome, Magazzino b) {
+        super(nome);
+        setShared(b);
+    }
+    
+    public void run(){
+        int i = 0;
+        while(true){
+            System.out.println(getName() + ": Inserisco " + i + " nel buffer");
+            getShared().put(i);
+            i += 1;
+        }
+    }
+}
+
+class Consumatore extends Actor{
+    public Consumatore(String nome, Magazzino b) {
+        super(nome);
+        setShared(b);
+    }
+    public void run(){
+        while(true){
+            int i = getShared().get();
+            System.out.println(getName() + ": Estraggo " + i + " dal buffer");
+
+        }
+    }
+}
+
+class Magazzino{
+    public final static int SIZE = 10;
+    private int[] memory = new int[SIZE];
+    private int quanti = 0;
+
+    public final int get() {
+        String n = Thread.currentThread().getName();
+        synchronized(syncPC){
+            while(isVuoto()){
+                System.out.println(n + " ha tentato di leggere");
+                try {
+                    syncPC.wait();
+                } catch (InterruptedException e) {
+                    System.err.println(e);
+                }
+            }
+            int ris = memory[--quanti];
+            if (quanti == SIZE - 1) syncPC.notifyAll();
+            System.out.println(n + " ha letto");
+            return ris;
+        }
+    }
+
+    public final void put(final int newMemory) {
+        String n = Thread.currentThread().getName();
+        synchronized(syncPC){
+            while (isPieno()){
+                System.out.println(n + " ha tentato di scrivere");
+                try {
+                    syncPC.wait();
+                } catch (InterruptedException e) {
+                    e.printStackTrace(System.err);
+                }
+            }
+            memory[quanti++] = newMemory;
+            if (quanti == 1) syncPC.notifyAll();
+            System.out.println(n + " ha scritto");
+        }
+    }
+
+    public final boolean isVuoto() {
+        return quanti == 0;
+    }
+
+    public final boolean isPieno() {
+        return quanti == SIZE;
+    }
+
+    private Object syncPC = new Object();
+}
+
+
+public class PC {
+
+    public static final void main(final String[] args) {
+        Magazzino x = new Magazzino();
+        Produttore a1 = new Produttore("Aldo", x);
+        Produttore a2 = new Produttore("Alberto", x);
+        Consumatore b = new Consumatore("Barbara", x);
+        a1.start();
+        b.start();
+        a2.start();
+    }
+
+}
+}}}
+
+