realizzare timer C#

[frank8085]

sto facendo un programma in cui ho la necessità di misurare il tempo di esecuzione di un set di istruzioni, qualcuno sa come aiutarmi? l'idea è di far partire un timer in un punto, fermarlo in un altro e scrivere il valore ottenuto in una variabile tempo (che conta i secondi)
ho provato 1000 cose ma nessuna funziona

[Kintaro10]

Utilizza l'oggetto Stopwatch (namespace System.Diagnostic):

Stopwatch - MSDN

Banalmente si utilizza così:

var sw = new Stopwatch();
sw.Start();    //parte il timer

//do stuff

//per stampare ad esempio su console il tempo passato utilizza
Console.WriteLine(string.Format("Tempo passato {0}", sw.ElapsedMilliseconds));

così ti da il tempo passato sino a quel momento. Se vuoi fermarlo, banalmente sw.Stop().
Un appunto: se per caso sei in debug l'esecuzione è ferma su un breakpoint, il timer continua a contare il tempo, quindi avresti una rilevazione errata.

Ciao

[frank8085]

alla fine ho risolto così:

// ....
var sw = new Stopwatch();

sw.Start(); //parte il timer

// elaborazione

sw.Stop();

MessageBox.Show("finito");
//.... altro
tempo = Convert.ToDouble(sw.ElapsedMilliseconds);
tempo = tempo / 1000;
//MessageBox.Show("tempo: " + tempo.ToString());
label3.Text = tempo.ToString();
//...continua

avrei un altra cosa da risolvere...vorrei far lavorare il programma in multithreading sfruttando tutta la potenza della CPU se necessario dato il tipo di programma, quindi non so se possiamo continuare a parlarne qui o magari devo aprire un nuovo thread

[Kintaro10]

Che versione del framework .NET utilizzi?

p.s.

MessageBox.Show("finito");
//.... altro
tempo = Convert.ToDouble(sw.ElapsedMilliseconds);
tempo = tempo / 1000;
//MessageBox.Show("tempo: " + tempo.ToString());

Non so cosa fai dentro //.... altro ma, se non vuoi che tale codice rientri nel tuo tempo di elaborazione, ti conviene spostare l'assegnazione della variabile tempo (tempo = Convert.ToDouble(sw.ElapsedMilliseconds); ) prima della show di "finito", sennò il tempo va avanti e non hai la misurazione corretta ai morsetti del tuo calcolo.

[frank8085]

uso la versione 4.6


provo...ma mi stai dicendo che il timer continua dopo l'istruzione STOP al punto che la messagebox interferisca sulla misurazione? ?!?!


ho VS2015, sono riuscito a verificare il tempo che intercorre tra la pressione del bottone: istante 2.55s alla messagebox "finito" (istante 6.22s), risultano 3.67s, il timer ha restituito: 3.669 ms, ovviamente VS penso che abbia fatto l'approssimazione del "9". quando fai il debug oltre ad indicare la memoria consumata, l'utilizzo % della CPU, ti dice anche la lista degli eventi scatenati e quale istante temporale risalgono rispetto l'avvio del programma

[Kintaro10]

No sorry svista mia, non avevo visto lo stop del timer. Per la domanda sul multithread ne parliamo qua o fai nuovo thread?

[frank8085]

se la cosa non va contro nessuna regola assurda io continuerei qua
queste erano quelle cosette di cui parlavo prima:

[Kintaro10]

Che tipo di operazioni vuoi compiere in multithread?

[frank8085]

in realtà questo programma è piuttosto banale, ho scoperto che facendo fare ciclicamente molte operazioni aritmetiche utilizzavo molte risorse, allora ho pensato di fare un programma di benchmark personale, una cosa ridicola per puro sfizio. ora praticamente premendo il pulsante vengono trovate tutte le potenze di 2 fino a 2^60 (sarebbe 2^64 un long/double ma io mi sono fermato un po' prima) dopodichè il valore viene riportato ad 1 e si ricomincia finchè non si sono fatte 1 miliardo di eleventi a potenza, misuro il tempo tra l'inizio del calcolo fino alla fine, in base al tempo attribuisco un punteggio...l'ho provato su 3 computer e dà risultati affidabili, ovviamente il programma usa un solo thread degli 8 disponibili almeno su questo pc.
ho alcuni mesi fa sperimentato la programmazione concorrente con il C++, ma non ho idea di come farla in C#, comunque creando gli N thread, tutti dovrebbero fare quello che ora fa uno solo, però sorgerebbe il problema del timer che non può essere univoco.

in ogni caso devo rischiararmi le idee

[Kintaro10]

Non ho ben capito se hai un loop o meno nel tuo programmino di test, comunque puoi usare due strade (entrambe della libreria System.Threading):

1. Parallel loop
   Si possono usare le funzioni for e foreach del costrutto Parallel; queste funzioni parallelizzano una serie di istruzioni al loro interno; se non specificato nulla, il calcolatore decide da solo quanti task staccare a seconda delle prestazioni della macchina, viceversa puoi dirgli te quanti farne al massimo.
   
2. Task factory
   In questo caso decidi te quando creare un task, cosa deve fare al suo interno, e quando il task principale deve attenderlo. Banalmente ne puoi creare uno con Task.Factory.StartNew (come ritorno hai il task stesso), e per aspettare uno o più task puoi usare ad esempio Task.WaitAll o Task.WaitAny . Questo argomento è un po' più ampio, vi sono più cose da poter vedere.

In tutti i casi stai attento ai problemi di concorrenza tra thread, usa se servono delle collection che gestiscono il multithreading (es. ConcurrentBag) oppure fai dei lock dove hai bisogno di accessi esclusivi.

Ciao

[frank8085]

scelgo l'opzione 1,
non ho capito esattamente il problema che hai detto alla fine,
io so alcune cose della programmazione concorrente che possono essere problematiche:
- non si possono fare previsioni sull'ordine di esecuzione dei thread
- questi possono intromettersi in qualunque momento dove in C++ non si usano le mutex che rendono un set di istruzioni "atomiche". vorrei vederci più chiaro sulla questione


ora devo capire come fare questo "parallel loop"

[Kintaro10]

I loop parallel sono il For ed il Foreach, in rete trovi un sacco di documentazione a riguardo, se poi hai problemi scrivi qua.

Per l'altro discorso ti faccio un esempio: tu hai una lista, su cui possono scrivere / leggere contemporaneamente più thread. Se gli accessi non sono gestiti accuratamente, potresti avere problemi con i dati (thread che leggono dati vecchi, oppure doppia scrittura contemporanea che genererebbe eccezione). Per ovviare a questi problemi puoi usare dei lock (come i semafori) oppure usare delle collection apposite messe a disposizione dal framework che includono già i controlli nelle get e set.

[frank8085]

il parallel.for funziona alla grande per ora, prima avevo lasciato un post in cui dicevo della non-uniformità dei risultati ma mi è venuto in mente che il risultato è fortemente condizionato da altri processi in esecuzione,
i risultati passano da 900ms a 2.5 secondi solo perchè ci sono 4 programmi aperti, per dare un risultato affidabile bisogna avere tutta la CPU a disposizione per quegli 8 thread.
ora l'unico dubbio riguarda l'adattamento ad altre macchine che non necessariamente hanno 8 thread, magari ne hanno solo 4 o magari ne hanno di più, ecco devo far fare un numero equo di calcoli (sempre 1 miliardo) indipendentemente dal numero dei thread disponibili, ma non voglio usarne un numero limitato in modo da adattarmi, voglio che si usino in tutti i casi quelli disponibili...
bisognerebbe sapere prima del lancio del calcolo il numero di processori virtuali disponibili, così da suddividere il miliardo di calcoli tra gli n thread. come potrei fare a parte chiederlo banalmente all'utente?

[Kintaro10]

Se quando dichiari il parallel for metti nessun parametro ulteriore, il programma in automatico utilizza tutte le risorse che il sistema gli dedica, e questo dovrebbe venire incontro alla tua richiesta; a seconda della potenza di calcolo del computer il framework "calibra" corettamente il for.

Se vuoi invece mettere un numero massimo, al parallel devi passare l'oggetto ParallelOptions, che ha come proprietà MaxDegreeOfParallelism che rappresenta il numero massimo di task da staccare.

P.s. per sapere il numero di core non serve chiederli all'utente, utilizza

Environment.ProcessorCount

[frank8085]

piuttosto di suddividere il calcolo come sto facendo adesso per simulare la distribuzione corretta dei calcoli tra i vari thread (ora se uno finge di avere 36 thread ci impiega molto meno ad eseguire il miliardo di calcoli, non perchè abbia effettivamente 18C/36T ma perchè ogni thread ha un carico 4.5 volte inferiore rispetto quello che avrebbe con un valore corretto (Es: 8 thread), facendo la modifica che ho in mente capita l'opposto, la CPU non riuscendo a parallelizzare 36 thread su una CPU che ne conta 8 per volta al massimo, ecco in questo caso mettere un valore più alto influisce negativamente e costringe l'esecuzione dei thread in 5 fasi (4,5 approssimato a 5), quindi saresti 4.5 volte più lento. beh questa è tutta teoria, devo verificarla nella pratica
ah sicuramente faccio la modifica per cui escludo l'utente dalla scelta, si è decisamente meglio così, in questo modo nessuno può "falsificare" il risultato mettendo un numero di thread non corretto.
si prenderò dal sistema il numero di thread effettivi, e poi in base al valore estrapolato suddivido il carico.

Grazie Mille