Python thread multipli/processi multipli per la lettura di porte seriali

Question

Sto provando a scrivere una classe python utilizzando l'elaborazione/threading parallela per la lettura di due porte seriali (/ dev/ttyS1 e/dev/ttyS2). Entrambe queste porte funzionano a una velocità di trasmissione di 19200 e sono costantemente attive. Ho usato pySerial per questo scopo.

Entrambe le operazioni di lettura devono essere eseguite in modo continuo e simultaneo. Mi chiedo se dovrebbe utilizzare la libreria di thread o la libreria di threading o la libreria di multiprocessing. Sono solo preoccupato a causa del blocco dell'interprete globale che non offre una vera capacità di threading per operazioni di I/O pesanti. Ma se il blocco dell'interprete globale non mi riguarda, userò il modulo threading/thread. Comunque se lo fa, dovrei compilare le librerie di multiprocessing di Python perché questo è su un sistema embedded.

Quindi il mio codice avrebbe in genere thread1 o process1 = lettura ttyS1 e scrittura su un buffer dopo l'esecuzione di alcune operazioni stringa sulle righe di lettura. thread2 o process2 = lettura ttyS2 e scrittura su un altro buffer dopo aver eseguito alcune operazioni stringa sulle righe di lettura. Altre funzioni ecc. Questi buffer sono ulteriormente utilizzati da altre parti nel codice.

Inoltre il multiprocessing in python richiede più core/cpus?

Grazie per la lettura!

Answer 1

Il GIL viene rilasciato durante le operazioni di lettura, quindi non dovrebbe influire molto su di voi. La compilazione incrociata multiprocessing suona come un'eccedenza eccessiva o almeno prematura. Mantenere il codice modulare in modo che lo possa passare in seguito, comunque.

Credo che le prestazioni di threading dipenderanno dal sistema operativo.Il tuo chilometraggio varierà, specialmente su un sistema embedded.

Se avete un'ora di ricambio, c'è un talk on the GIL di David Beazley (PDF diapositive here). Per il threading ad alte prestazioni, ti consigliamo di vederlo per ottenere i dettagli sgradevoli su come il threading, GIL e il sistema operativo possono lavorare tutti insieme per eliminare le prestazioni.

Answer 2

Non sono un esperto in materia in alcun modo, ma continuo a scoprire che la quantità di sottigliezze aggiuntive che utilizzano threading non vale la pena se posso parallelizzare tramite processi.

Un terzo modulo che non hai menzionato tra le alternative è subprocess.

EDIT su richiesta dell'OP: È possibile ottenere l'elaborazione parallela creando script separati per le interfacce seriali. Questa è una demo rapida, presuppone che entrambi i file siano nella stessa directory.

File com.py - lo script di serie - Questa è solo una finta, ma l'idea è che lo script viene eseguito in modo autonomo, e utilizza solo stdin e stdout per comunicare con il programma di master.

import sys 

counter = 0 
while True: # The program never ends... will be killed when master is over. 
    counter += 1 
    sys.stdin.readline() 
    sys.stdout.write('Serial from com1 is %d\n' % counter) 
    sys.stdout.flush() 

File master.py - il programma principale

from subprocess import Popen, PIPE 
from time import sleep 

p = Popen(['python', './com.py'], stdin=PIPE, stdout=PIPE, stderr=PIPE) 
print "serial communication started." # com.py is working but we moved on! 
for i in range(3): 
    p.stdin.write('<command-here>\n') 
    print "comand sent." 
    print "received : %s" % p.stdout.readline() 
    sleep(1) 

Infine, si tratta di una discarica del risultato atteso:

mac@jabbar:~/Desktop$ ./master.py 
serial communication started. 
comand sent. 
received : Serial from com1 is 1 
comand sent. 
received : Serial from com1 is 2 
comand sent. 
received : Serial from com1 is 3 

HTH!