Mentre si lavora in un ambiente multi-thread, la condivisione dei dati sembra essere una buona opzione per passare i dati tra i thread.
Mentre si lavora con sistemi in tempo reale è apparentemente consigliabile andare con l'ottimizzazione della memoria.
Quindi, nel mio scenario, ho un consumatore e un produttore. Condividono una coda di qualsiasi tipo di dati e.g int queue . Ora il produttore genera dati e amp; copia i dati in coda ed emette un segnale al consumatore che sta aspettando il segnale come segue:
thread 1:
pthread_mutex_lock(&mutex);
while (!condition)
pthread_cond_wait(&cond, &mutex);
/* do something that requires holding the mutex and condition is true */
pthread_mutex_unlock(&mutex);
thread2:
pthread_mutex_lock(&mutex);
/* do something that might make condition true */
pthread_cond_signal(&cond);
pthread_mutex_unlock(&mutex);
Quando il produttore genera i dati nella coda ed emette un segnale, il consumatore riceve quel segnale e amp; blocca la coda per entrare in una sezione critica.
Ora, il consumatore deve copiare quei dati o elaborarli direttamente nella sezione critica? Quale opzione è consigliabile?
Consideriamo un esempio in tempo reale, il mio thread di produzione genera dati ad ogni 50ms e come per codice, blocca la coda ogni 50 ms, copia i dati in coda, emette un segnale e si sblocca.
Una volta che il consumatore riceve il segnale, deve elaborare i dati. Ma, prima di elaborare i dati, il consumatore internamente blocca prima la coda.
Quindi, prima che i dati vengano elaborati, devono essere copiati per primi o possono essere elaborati direttamente e quindi sbloccati?
FYI, il consumatore impiega solo 1ms di tempo per elaborare.
In questo scenario, la copia della memoria è più efficiente o è il puntatore alla memoria?