Différences

Ci-dessous, les différences entre deux révisions de la page.

--- python_multiprocessing [2021/08/12 17:17] – [Python est lent et n'est pas multiprocess] serge
+++ python_multiprocessing [2022/06/21 13:42] (Version actuelle) – [Mon exemple à moi archi simple] serge
@@ Ligne 1: / Ligne 1: @@
 ====== Python: Multiprocessing et GIL ======
 =====Python est lent et n'est pas multiprocessus=====
 Balivernes ... billevesées ... \\
-Toutes les Intelligences Artificielles ont une façade en python ... Dja daja (ah bon!)\\
+Toutes les Intelligences Artificielles ont une façade en python ... Dja dja (ah bon!)\\
 L'interpréteur python est généralement CPython qui est comme son nom l'indique écrit en C, le C serait lent ?
-=====Ressources sur le module multiprocessing=====
+=====GIL=====
+  * **https://realpython.com/python-gil/**
+Le module threading permet de lancer des tâches en parallèles, mais en réalité elles ne le sont pas: tout se fait sur un seul cœur du processeur. Les tâches sont découpées en petits bouts, exécution d'un bout d'une, puis un petit de l'autre, etc ...
+Le GIL (Global Interpreteur Lock) évite de surcharger un thread.
+Le module multiprocessing utilise réellement un cœur pour chaque tâche, et il est possible que chaque tâche communique avec une autre.\\
+Par contre, un processus n'utilise toujours qu'un seul cœur.
+=====Ressources sur le module multiprocessing=====
   * http://www.kasimte.com/multiprocessing-in-python-pool-process-queue-and-pipe
   * https://stackoverflow.com/questions/11515944/how-to-use-multiprocessing-queue-in-python
@@ Ligne 16: / Ligne 21: @@
   * https://www.geeksforgeeks.org/multiprocessing-python-set-2/
-Mais comme souvent, les tutos sont hyper-compliqués, les auteurs montrent qu'ils sont très fort avec des exemples inappropriés.
+Mais comme souvent, les tutos sont hyper-compliqués, les auteurs montrent qu'ils sont très forts avec des exemples inappropriés.
 ===Remarques===
 Certains modules, tel que numpy, sont déjà multiprocess.
-=====GIL=====
+=====Exemples de Multiprocessing=====
-Le module threading permet de lancer des tâches en parallèles, mais en réalité elles ne le sont pas: tous se fait sur un seul cœurs du processeur. Les tâches sont découpées en petits bouts, excécution d'un bout d'une, puis un petit de l'autre, etc ...
-Le GIL (Global Interpreteur Lock) évite de surcharger un thread.
-Le module multiprocessing utilise réellement un cœur pour chaque tâche, et il est possible que chaque tâche communique avec une autre.\\
-Par contre, un processus n'utilise toujours qu'un seul cœur.
-=====Exemples=====
 Je vous propose des exemples simples:
 <file python multiprocessing_example_1.py>
 """
-Example d'utilisation de multiprocessing
+Exemple d'utilisation de multiprocessing
 documentation
@@ Ligne 74: / Ligne 71: @@
 <file python multiprocessing_example_2.py>
 """
-Example d'utilisation de multiprocessing
-et communication entre process avec
-Pipe, Queue
-documentation
+Exemple de 2 processus qui tournent en parallèle et échangent une variable avec Pipe.
-https://docs.python.org/3/library/multiprocessing.html
-Exemple de 2 processus qui tournent en parallèle et échange une variable
-avec Pipe.
 https://docs.python.org/3/library/multiprocessing.html#exchanging-objects-between-processes
@@ Ligne 138: / Ligne 128: @@
     main()
 </file>
-{{tag>python sb}}
+=====Multiprocess dans kivy=====
+Une application kivy qui excécute pyrealsense et coral dans un Process avec Pipe marche impeccable.
+  * **[[https://github.com/sergeLabo/personnages3d| sergeLabo personnages3d]]** Détection de 1 à 4 personnes
+    * Inferface graphique réalisée avec Kivy\\
+    * Suivi des personnes devant la caméra
+=====multiprocessing.shared_memory =====
+====Ressources====
+  * **[[https://docs.python.org/fr/3.9/library/multiprocessing.shared_memory.html|docs.python.org/fr Mémoire partagée en accès direct depuis plusieurs processus¶]]**
+====Mon exemple à moi archi simple====
+**Je n'ai pas besoin de montrer que je suis très fort pour me faire embaucher chez GAFAM.**
+<code python>
+from time import time, sleep
+import random
+from multiprocessing import Process
+from multiprocessing.sharedctypes import Value
+class SharedMemory:
+    def __init__(self):
+        self.val = Value("i", -4000)
+        print(self.val, self.val.value)
+        my_proc = Process(target=another_process,  args=(self.val, ))
+        my_proc.start()
+    def shared_memory_master(self):
+        t = time()
+        while time() - t < 4:
+            print(f"Lecture de {self.val}: {self.val.value}")
+            sleep(0.1)
+def another_process(val):
+    t = time()
+    while time() - t < 3:
+        n = random.randint(-1000, 1000)
+        print(f"Maj de n = {n}")
+        val.value = n
+        sleep(0.3)
+if __name__ == "__main__":
+    sh = SharedMemory()
+    sh.shared_memory_master()
+</code>
+====Exemple d'utilisation bas niveau d'instances de SharedMemory====
+<code python>
+from multiprocessing import shared_memory
+shm_a = shared_memory.SharedMemory(create=True, size=10)
+m = shm_a.buf
+print('type(m)', type(m))
+buffer = shm_a.buf
+print('len(buffer)', len(buffer))
+# Modify multiple at once
+buffer[:4] = bytearray([22, 33, 44, 55])
+# Modify single byte at a time
+buffer[4] = 100
+# Attach to an existing shared memory block
+shm_b = shared_memory.SharedMemory(shm_a.name)
+import array
+# Copy the data into a new array.array
+ar = array.array('b', shm_b.buf[:5])
+print('ar', ar)
+# Modify via shm_b using bytes
+shm_b.buf[:5] = b'howdy'
+# Access via shm_a
+print('bytes(shm_a.buf[:5])', bytes(shm_a.buf[:5]))
+# Close each SharedMemory instance
+shm_b.close()
+shm_a.close()
+# Call unlink only once to release the shared memory
+shm_a.unlink()
+</code>
+====Exemple de partage de numpy array====
+<code python>
+from multiprocessing import Process
+from multiprocessing.managers import SharedMemoryManager
+from multiprocessing.shared_memory import SharedMemory
+import numpy as np
+def test(shared_mem: SharedMemory, dtype):
+    a = np.frombuffer(shared_mem.buf, dtype=dtype)
+    a[0] = -a[0]
+if __name__ == "__main__":
+    # Create the array
+    N = int(10)
+    unshared_arr = np.random.rand(N)
+    DTYPE = unshared_arr.dtype
+    with SharedMemoryManager() as smm:
+        shared_mem = smm.SharedMemory(size=unshared_arr.nbytes)
+        arr = np.frombuffer(shared_mem.buf, dtype=DTYPE)
+        arr[:] = unshared_arr
+        print("Originally, the first two elements of arr = %s" % (arr[:2]))
+        # Create, start, and finish the child processes
+        p = Process(target=test, args=(shared_mem, DTYPE))
+        p.start()
+        p.join()
+        # Printing out the changed values
+        print("Now, the first two elements of arr = %s" % arr[:2])
+</code>
+{{tag> kivy python sb }}