C ++ mikrosekunder

For å få en nøyaktig utførelsestid i et C ++ -program, gir C ++ programmeringsspråket flere alternativer. Du kan skrive din tilpassede kode for å få den nøyaktige utførelsestiden, eller du kan bruke den innebygde funksjonen som sparer tid og energi. Den innebygde funksjonen levert av C ++ programmeringsspråket hjelper utvikleren til å implementere komplekse prosesser med bare en enkelt funksjon. I denne artikkelen vil vi lære å få den nøyaktige og presise utførelsestiden i mikrosekunder ved bruk av C ++ innebygde funksjoner. Det er forskjellige måter å finne utførelsestiden i mikrosekunder.

Beregning av utførelsestiden for C ++ -programmet i mikrosekunder

Dessverre er det ingen metoder for å finne ut av den nøyaktige utførelsestiden som fungerer for alle. For det må du velge løsningen i henhold til situasjonen. Å måle den nøyaktige utførelsestiden for et C ++ -program kan være vanskelig i noen situasjoner på grunn av portabilitetsproblemer. Å velge riktige metoder som passer med operativsystemet ditt og kompilatorversjonen er viktig for å få en nøyaktig tid. Enda viktigere er at du må forstå hva du mener med "tiden" slik at du kan velge metoden deretter.

Her finner du en omfattende liste over noen enkle, enkle og beste alternativer som er tilgjengelige for å finne utførelsestiden for et C ++ -program. Vi vil også liste opp begrensningene for funksjonene (e) for å gi deg en heads-up før du begynner å bruke den funksjonen i programmet ditt.

Forhåpentligvis vil du få det beste alternativet perfekt for ditt operativsystem og kompilatorversjon.

Eksempel 1:

Vi vil undersøke veggtid med funksjonen. Funksjonen er en av de mest bærbare måtene å finne veggtiden i et C ++ -program. Det fungerer bare med C ++ 11 og senere versjoner. Hvis du har en eldre versjon, kan du oppgradere kompilatoren din før du bruker denne funksjonen. Den har tilgang til forskjellige typer klokker i maskinen som har forskjellige egenskaper og formål.

Her bruker vi High_Resolution_Clock for å finne veggtiden da den bruker den høyeste oppløsningsklokken som er tilgjengelig, noe som sannsynligvis er tilstrekkelig for de fleste systemer. Se koden gitt nedenfor:

#inkludere
#inkludere
int main ()
dobbel s = 0, a = 1;
auto start = std :: chrono :: high_resolution_clock :: nå ();
int IT = 1000*1000*1000;
for (int i = 0; is += a;
A /= 2.0;

auto end = std :: chrono :: high_resolution_clock :: nå ();
Auto Elapsed = Std :: Chrono :: Drice_cast (End - Start);
printf ("Klokken begynner på = %.2f \ n ", s);
printf ("målt tid er = %.3f sekunder.\ n ", gått.count () * 1e-6);
retur 0;

Programmet starter med to overskriftsfiler stdio.H og Chrono. Stdio.H -bibliotek brukes i forbindelse med standardinngangs- og utgangsmetodene. Chrono -biblioteket lar deg bruke funksjonen i programmet ditt. Hele programmet er skrevet i hovedfunksjonen der all utførelse skjer.

Hovedprogrammet starter med å initialisere to variabler 's', og 'A' som vil bli brukt for å holde oversikt over tiden. "Start" -variabelen initialiseres med gjeldende tid med 'Chrono :: High_Reolution_Clock :: Now ()' -funksjonen.

Variabelen 'IT = 1000*1000*1000' initialiseres med antall iterasjoner som må utføres og beregner den forløpte tiden i mikrosekunder. Følgende handling vil bli utført av "for" -sløyfen når den itererer fra 0 til 1000*1000*1000 ganger.

En annen variabel 'ende' initialiseres med gjeldende tid for å sjekke den forløpte tiden. Når du beregner 'slutt - start' vil du få den forløpte utførelsestidspunktet. 'Chrono :: mikrosekunder' vil gi utførelsestiden i mikrosekunder som vil bli konvertert til sekunder med 'forløpt.Count ()*1E-6 'Beregning. Utskrift () -uttalelsene vil skrive ut starttid og forløpt tid. Og til slutt sikrer Return 0 -uttalelsen at programmet blir utført med hell.

Når du kjører den komplette koden, vil det bli produsert en lignende utgang avhengig av utførelseshastighet og effektivitet i systemet ditt:

Eksempel 2:

I koden gitt nedenfor bruker vi GetTimeOfDay () -funksjonen for å finne den forløpte tiden siden Epoch Time er '1. januar 1970, 00:00:00 UTC'. GetTimeOfDay () -funksjonen returnerer tiden i både mikrosekunder og sekunder. For å finne den nøyaktige tiden i mikrosekunder, må begge ganger summeres sammen. Under vedlagte kode hjelper deg med å beregne utførelsestiden i mikrosekunder ved bruk av

#inkludere
#inkludere
int main ()
dobbel s = 0, a = 1;
Struct TimeVal Start, slutt;
GetTimeOfDay (& Start, 0);
int IT = 1000*1000*1000;
for (int i = 0; is += a;
A /= 2.0;

GetTimeOfDay (& End, 0);
Lang SEC = slutt.TV_sec - Start.TV_sec;
lang mikro = ende.TV_USEC - Start.TV_USEC;
dobbelt forløpt = sek + mikro*1e-6;
printf ("Klokken begynner på = %.20f \ n ", s);
printf ("målt tid er = %.3f sekunder.\ n ", gått);
retur 0;

Funksjonen GetTimeOfDay () er inkludert i overskriftsfilen.

'Struct TimeVal' er en tidsvalstruktur som brukes til å representere den forløpte tiden.

Beregnet tid på sekunder og mikrosekunder legges til for å få den nøyaktige utførelsestiden i mikrosekunder. 'TV_sec' -funksjonen gir tiden på sekunder og 'TV_USEC' gir tiden i mikrosekunder. For å konvertere sekundene til mikrosekunder, multipliser du mikrosekundene med 1E-6. Etter det, legg til begge ganger på sekunder og mikrosekunder for å få den nøyaktige utførelsestiden i mikrosekunder.

Nå, klikk på kompilerings- og kjør -ikonet i ikonlinjen til Dev C ++ programvare. Trykk på F11 -tasten på tastaturet for å utføre programmet. Den utførte utgangen er gitt nedenfor:

Eksempel 3:

I dette eksemplet bruker vi biblioteket og dets tid () -funksjon. Tid () -funksjonen fungerer på samme måte som GetTimeOfDay () -funksjonen som gir den forløpte tiden siden epoke -tiden. Imidlertid måler den bare hele sekunder, og du kan ikke definere tidssonen. Derfor, hvis de målte intervallene er mer enn et sekund, er det fornuftig tid (). Dette er kanskje ikke den første preferansen for å få mikrosekundene, og du kan bruke andre funksjoner i stedet. Se koden nedenfor:

#inkludere
#inkludere
int main ()
dobbel s = 0, a = 1;
TIME_T START, END;
tid (og start);
int IT = 1000*1000*1000;
for (int i = 0; is += a;
A /= 2.0;

tid (& slutt);
TIME_T ELAPSERT = END - Start;
printf ("Resultat: %.20f \ n ", s);
printf ("Tid målt: %LD sekunder.\ n ", gått);
retur 0;

Tid () -funksjonen vil gi start- og slutttidsutførelse og forløpt tid kan enkelt beregnes med en "slutt - start" -uttalelse. Se resultatet nedenfor:

Merk at den forløpte tiden beregnet med tid () -funksjonen er 6s, ikke nøyaktig 6.833 mikrosekunder. Forskjellen i resultatet av tiden () -funksjonen sees i utgangen.

Konklusjon

Ulike metoder beregner utførelsestiden for systemet ved hjelp av et C ++ -program. Imidlertid er ingen løsning perfekt for hver situasjon, og hver funksjon fungerer annerledes i forskjellige situasjoner. Her lærte vi å bruke tiden (), GetTimeOfDay () og funksjoner for å få utførelsestiden i mikrosekunder.