Thread_status
La classe permette la gestione di eventi e del loro stato.
Eventi
Gli eventi sono utili quando un thread deve essere in grado di stabilire quando eseguire la relativa attività. Ad esempio, un thread che trasferisce dati ad una stampante deve ricevere una notifica quando sono disponibili nuovi dati. La classe Thread_status fornisce un’interfaccia per gestire un insieme di eventi, permettendo la loro attivazione, disattivazione e verifica dello stato. Gli eventi sono gestiti a livello del sistema operativo e possono essere testati all’interno dei thread per gestire il flusso dell’elaborazione. Ciascun oggetto di tipo Thread_status gestisce un insieme di MAX_EVENTS eventi attivabili, ciascuno individuato da un valore HEVENT ,
#define MAX_EVENTS 32 #define HEVENT int
HEVENT è un valore compreso fra 1 e MAX_EVENTS. I valori compresi fra 1 e (EV_USER-1) sono riservati per gestire eventi standard nella gestione dei thread di Colibrì. Attualmente sono definiti i seguenti codici, relativi allo stato dei thread derivati da CLB_thread:
/** codice evento start thread */ #define EV_START 1 /** codice evento fine thread */ #define EV_END 2 /** codice evento termina thread */ #define EV_EXIT 3 /** codice evento stop da esterno del thread */ #define EV_STOPPED 4 /** codice iniziale evento utente */ #define EV_USER 10
Nota: istanze diverse delle Thread_status individuano con lo stesso valore HEVENT eventi distinti, caratteristici del thread considerato: ad esempio, EV_START identifica l’evento di lancio dell’esecuzione di un thread specifico; Inoltre, ciascun thread può gestire eventi specifici definiti dal programmatore, ad esempio un evento che indica la terminazione di un ciclo di trasferimento di dati in un particolare thread potrebbe essere definito come segue:
#define EV_END_MY_TRANSFER EV_USER+3
notare che la definizione usa un id nella zona di valori >=EV_USER.
Analizziamo ora in dettaglio le funzioni e metodi della classe:
class AFX_EXT_CLASS Thread_status
{
public:
Thread_status();
virtual ~Thread_status();
void Lock();
void UnLock();
void WaitEvent(HEVENT ev_code);
void SetEvent(HEVENT ev_code);
bool Verified(HEVENT ev_code);
bool NotVerified(HEVENT ev_code);
void Init();
bool GetStatus(HEVENT ev_code);
void SetStatus(HEVENT ev_code, int value = 1);
void StopTask();
static void SigStart(char *file, char *function);
static void SigEnd(char *file, char *function);
static void Dump(STRING filename);
__use_private_struct
};
SetEvent(HEVENT ev_code)
Imposta lo stato dell’evento ev_code su segnalato, rilasciando eventuali thread in attesa. Cli eventi gestiti possono essere di tipo automatico o manuale (vedi la classe CEvent). in Thread_status gli eventi gestiti sono tutti automatici. Un evento automatico ritorna automaticamente a uno stato non segnalato (non disponibile) dopo che è stato rilasciato almeno un thread.
WaitEvent(HEVENT ev_code)
Pone il thread in uno stato di attesa della segnalazione dell’evento ev_code; la funzione ritorna quando l’evento si è verificato. Le funzioni SetEvent e WaitEvent sono usate all’interno delle due macro _EWAIT ed _ESIG sono usate internamente al codice dei thread per verificare lo stato degli eventi.
bool Verified(HEVENT ev_code)
Ritorna true se l’evento si è verificato. E’ utilizzato per verificare lo stato di un evento ma, a differenza di WaitEvent, non rimane in attesa della verifica (segnalazione)
bool NotVerified(HEVENT ev_code)
Ritorna true se l’evento non si è verificato (ancora verificato). Il controllo dello stato dell’evento è, come Verified, immediato. Può come Verified essere utilizzato in un Loop di attesa (vedremo in seguito alcuni esempi).
void Init()
Azzera tutti i semafori e gli eventi gestiti dalla classe. La funzione è usata intervnamente nella inizializzazione della classa CLB_threads. Non deve essere usata in contesti diversi.
bool GetStatus(HEVENT ev_code)
Ad ogni evento è associato uno bit interno che viene alzato quando l’evento si verifica, indipendentemente dalla cattura dello stesso (ved WaitEvent, ad esempio);
ad esempio la GetStatus(EV_START) rimanda true se il thread è stato attivato (lanciato), anche se si trova in uno stato di wait..
void SetStatus(HEVENT ev_code, int value = 1)
La funzione è usata per segnalare lo stato di un evento attivato, e serve per testare dall’esterno che l’evento sia stato alzato almeno una volta. Non approfondiremo per ora le due funzioni GetStatue e SetStatus, segnalando che comunque devono essere considerate obsolete e saranno rimosse in una prossima revisione della libreria
void Stop_thread()
Ricordiamo che la classe Thread_status è l’interfaccia di gestione di eventi ereditata dalla classe CLB_thread
Stop_thread è una funzione che blocca l’esecuzione del thread ed attende che lo stesso Venga terminato (cioè che si verifichi l’evento EV_END). Per le modalità di definizione dei thread di Colibri, la terminazione del CLB_thread di appartenenza è certamente effettuata, eseguendo automaticamente tutte le funzionalità di rilascio degli oggetti e memoria usati internamente al thread stesso.
nel seguito di questo articolo faremo un esempio di come viene utilizzata questa funzione.
Funzioni di debug
Le due funzioni SigStart(..) e SigEnd(..) sono utilizzabili per monitorare lo stato di attività dei thread nell’analisi della loro efficienza. Per ora non ne forniamo alcuna descrizione (lo faremo in un successivo articolo).
Nota: Quasi mai avremo la necessità di accedere direttamente all’interfaccia Thread_status; l’accesso alle sue funzionalità è sempre fatto attraverso i comandi del linguaggio CLB_lang del framework di Colibrì.
