PerformanceCounter
La classe PerformanceCounter sfrutta i clock hardware presenti in num di cicli di esecuzione. I timestamp e le misurazioni degli intervalli di tempo sono parte integrante delle misurazioni delle prestazioni del computer e della rete. Queste operazioni di misurazione delle prestazioni includono il calcolo del tempo di risposta, della velocità effettiva e della latenza, nonché l’esecuzione del codice di profilazione. Ciascuna di queste operazioni comporta una misurazione delle attività che si verificano durante un intervallo di tempo definito da un evento di inizio e fine che può essere indipendente da qualsiasi riferimento esterno dell’ora del giorno.
class AFX_EXT_CLASS PerformanceCounter
{
public:
PerformanceCounter(void);
virtual ~PerformanceCounter(void);
// inizia misura ciclo;
void Start(void);
// fine del ciclo: il numero di cicli utilizzati fra Start() ed End() vengono sommati al
// totalizzatore num_cicli;
void End(void);
// rimanda il numero medio di cicli per iterazione testata
int NumMedioCicli();
// rimanda il numero di iterazioni testate
unsigned int NumTest();
float Secondi();
// rimanda una stringa html con le informazioni sullo stato del counter
STRING Get_info();
// display dello stato del counter
void Display();
// azzera lo stato del counter;
//
void Reset();
/** rimanda un nuovo elemento
*/
static PerformanceCounter *Create(
STRING name ///< Nome assegnato
);
/** visualizza le statistiche di tutti i PerformanceCounter attivi
*/
static void DisplayStats();
/** distrugge tutti i rilevatori di performance attivi nel software
*/
static void Destroy();
__use_private_struct
};
La classe, attraverso la funzione statica Create() gestisce una lista di PerformanceCounter, a ciascuno dei quali è assegnato un nome. L’uso più comune della classe è la gestione di un insieme di timer, ciascuno associato all’esecuzione di un thread, prevedendo che nel corso dell’esecuzione del codice, ciascun thread possa essere chiamato più volte. Se il thread contiene un blocco di codice come il seguente
..... $_pc_start(pfc); ..... ..... blocco di codice da eseguire .... $_pc_end(pfc);
dove pfc è un PerformanceCounter * ottenuto in fase di inizializzazione mediante la funzione statica PerformanceCounter ::Create(L”my_timer_name”), la $_pc_end(pfc) memorizza il numero di cicli di esecuzione del blocco iniziato da $_pc_start(pcf), ed incrementa il numero di volte di esecuzione del blocco.
A fine utilizzo il programmatore potrà ricavare le informazioni di esecuzione del blocco richiamando la funzione statica PerformanceCounter ::DisplayStats(), che visualizzerà la statistica d’uso di tutti i blocchi di codice sui quali è definito un PerformanceCounter (nel nostro caso pcf).
Per semplificare la gestione dei timer, vengono in genere usate alcune macro di CLB_language.
#define $_pc_reset(p) if (p) p->Reset(); #define $_pc_create(p,tit) p = CLKS::PerformanceCounter::Create(tit); #define $_pc_start(p) if (p) p->Start(); #define $_pc_end(p) if (p) p->End(); #define $_pc_display_statistics CLKS::PerformanceCounter::DisplayStats(); #define $_pc_destroy_all CLKS::PerformanceCounter::Destroy();
Le macro richiamano le funzioni della classe per dichiarare, inizializzare e gestire un insieme di PerformanceCounter; per esempio, supponiamo di dovere analizzare le performance di tre diversi blocchi di esecuzione di codice. per prima cosa, in fase di inizializzazione definiremo da qualche parte i timer necessari:
... ... // PerformanceCounter declarations... CLKS::PerformanceCounter *p1 = 0, *p2 = 0, *p3 = 0; ... ...
quindi, in un successivo pezzo di codice creeremo le tre istanze
... ... // create 3 PerformanceCounter ... $_pc_create(p1, L" total calculation timecode") $_pc_create(p2, L" using kernel") $_pc_create(p3, L" file write") ... ...
La $_pc_create genera l’istanza PerformanceCounter ed azzera i contatori interni (PerformanceCounter ::Reset())
successivamente, se necessario, sarà possibile inizializzare nuovamente un’istanza utilizzando la macro $_pc_reset:
// if you want to reset internal counters.. .. $_pc_reset(p1) .. $_pc_reset(p2) .. $_pc_reset(p3)
Quindi, di seguito sono riportati gli schemi di tre blocchi di codice, ciascuno testato attraverso i tre PerformanceCounter p1,p2,p3. Non è definita la posizione dei tre blocchi, che potrebbero appartenere a thread diversi o a funzioni diverse..
...
...
// block code 1
{
$_pc_start(p1)
... // code to test..
...
$_pc_end(p1)
}
...
...
// block code 2
{
$_pc_start(p2)
... // code to test..
...
$_pc_end(p2)
}
...
...
// block code 3
{
$_pc_start(p3)
... // code to test..
...
$_pc_end(p3)
}
..
..
Ciascun blocco inizia con la macro $_pc_start(px) e termina con $_pc_end(px). In questo modo Il codice tiene così traccia di quante volte è stato eseguito un blocco e dei tempi di calcolo relativi. Terminato l’uso, quando si riterrà necessario, potrà essere visualizzato lo stato dell’esecuzione mediante la macro $_pc_display_statistics
... $_pc_display_statistics ...
che produrrà una finestra del tipo:
La finestra visualizzerà le informazioni relative ai PerformanceCounter utilizzati (nel nostro caso quelli i cui nomi sono riportati in arancione, indicando il tempo totale di esecuzione in microsecondi. Se fossero stati eseguiti più volte i blocchi di codice relativi, oltre che il tempo totale di calcolo sarebbero stati visualizzati anche il numero di esecuzioni ed il tempo medio di esecuzione di ciascun blocco.
Infine, quando si terminerà l’esecuzione del codice, ad esempio a distruzione della classe che conteneva le funzioni, sarà necessario rilasciare tutti i PerformanceCounter utilizzati. L’operazione sarà fatta utilizzando la macro $_pc_destroy_all
.. .. // destroy all PerformanceCounter.. $_pc_destroy_all ..
Attenzione: La macro $_pc_destroy_all distrugge tutti i PerformanceCounter definiti nel software e in genere non è necessario usarla se si intende riutilizzare le istanze in più fasi di esecuzione. Tutte le istanze saranno comunque rilasciate a terminazione del programma.
