ఇందులో Linux సూచన వ్యాసం, ఎలా ఉపయోగించాలో మేము మీకు చూపుతాము గడియారం() ఫంక్షన్, ఒక నిర్దిష్ట ప్రక్రియ లేదా థ్రెడ్ యొక్క ఎగ్జిక్యూషన్ టైమ్‌లను కొలవడానికి C భాషలో అందుబాటులో ఉన్న వనరులలో ఒకటి.
సమయం యొక్క ఈ భిన్నాలు చాలా తక్కువగా అనిపించినప్పటికీ, ఈ చిన్న భిన్నాలను కొలిచే మరియు లెక్కించే సామర్థ్యం సిస్టమ్ లేదా ప్రక్రియ యొక్క ఖచ్చితత్వంలో కీలకమైన కారకాలుగా ఉన్న క్లిష్టమైన సందర్భాలు ఉన్నాయి. ఎలా అనేదానికి మేము సైద్ధాంతిక వివరణ ఇస్తాము గడియారం() పనిచేస్తుంది, దాని ఆపరేషన్ మరియు ఈ ప్రయోజనం కోసం ఉపయోగించే కొలత యూనిట్లను వివరించండి.
ఆపై, కోడ్ శకలాలు మరియు చిత్రాలను కలిగి ఉన్న ఆచరణాత్మక ఉదాహరణలను ఉపయోగించి, వివిధ సిస్టమ్‌లలోని నిజ-సమయ ప్రక్రియలలో క్లిష్టమైన సమయాలను కొలవడానికి మీరు ఈ ఫంక్షన్‌ను స్పష్టమైన మరియు వివరణాత్మక మార్గంలో ఎలా అమలు చేయవచ్చో మేము చూస్తాము.
క్లాక్() ఫంక్షన్ సింటాక్స్:
clock_t గడియారం ( శూన్యం )
C లాంగ్వేజ్‌లో క్లాక్() ఫంక్షన్ వివరణ
కాల్ చేసినప్పుడు క్లాక్() ఫంక్షన్ ఖాళీగా ఉంటుంది. ఇది ఇన్‌పుట్ ఆర్గ్యుమెంట్‌లను కలిగి ఉండదు మరియు కాల్ సమయంలో “clock_t”లో గడియారం యొక్క టిక్‌ల సంఖ్యను అందిస్తుంది.
అప్లికేషన్ ప్రారంభించబడినప్పుడు పల్స్ కౌంట్ సున్నా వద్ద ప్రారంభమవుతుంది మరియు వినియోగదారు లేదా సిస్టమ్ దాని నుండి నిష్క్రమించే వరకు కొనసాగుతుంది, దాదాపు ప్రతి 72 నిమిషాలకు ఓవర్‌ఫ్లో ద్వారా సున్నాకి రీసెట్ చేయబడుతుంది. గడియారం() ఫంక్షన్ సవరించదు లేదా ఈ కౌంటర్‌పై నియంత్రణను కలిగి ఉండదు; అది పిలిచినప్పుడు మాత్రమే దాని విలువను పొందుతుంది.
ప్రోగ్రామ్ యొక్క మొత్తం ఎగ్జిక్యూషన్ సమయాన్ని కొలవడానికి, మేము ప్రోగ్రామ్ ముగింపులో గడియారాన్ని () ఒక్కసారి మాత్రమే కాల్ చేయాలి. ప్రోగ్రామ్ యొక్క ఒక పాయింట్ నుండి మరొకదానికి గడిచిన సమయాన్ని కొలవడానికి, మేము గడియారం () ఫంక్షన్‌కు కాల్ చేయాలి మరియు పొందిన రెండు డేటాను లెక్కించాలి.
యొక్క రెండు కాల్‌ల మధ్య గడిచిన టిక్‌లను గుర్తించడానికి గణన గడియారం() మొదటి కాల్ ఫలితాన్ని రెండవ కాల్ ఫలితం నుండి తీసివేయడం ద్వారా ఫంక్షన్ జరుగుతుంది. ప్రోగ్రామ్ యొక్క ఒక పాయింట్ నుండి మరొకదానికి గడిచిన సమయాన్ని నిర్ణయించడానికి ఒక ఉదాహరణను చూద్దాం.
ది గడియారం() ఫంక్షన్ 'time.h' హెడర్ ఫంక్షన్లలో నిర్వచించబడింది. దీన్ని ఉపయోగించడానికి, కింది చిత్రంలో చూపిన విధంగా మన “.c” లేదా “.h” కోడ్ ఫైల్‌లో తప్పనిసరిగా చేర్చాలి.
#includeక్లాక్() ఫంక్షన్‌తో ప్రోగ్రామ్‌లోని ఒక పాయింట్ నుండి మరొక పాయింట్‌కి గడిచిన క్లాక్ టిక్‌లను ఎలా పొందాలి
ఈ ఉదాహరణలో, ప్రోగ్రామ్‌లోని ఒక పాయింట్ నుండి మరొకదానికి గడిచిన టిక్‌ల సంఖ్యను ఎలా పొందాలో చూద్దాం. ఈ రెండు పాయింట్లు రెండు కాల్‌లలో ఒకదానికి అనుగుణంగా ఉంటాయి గడియారం() ఫంక్షన్, వరుసగా. దీన్ని అర్థం చేసుకోవడానికి, కింది కోడ్‌ను చూద్దాం:
#
#include
శూన్య ప్రధాన ( )
{
clock_t ticks_ini, ticks_end;
డబుల్ పేలు;
ticks_ini = గడియారం ( ) ; // కొలత ప్రారంభం
printf ( 'టిక్స్ init కొలత %ld \n ' , ticks_ini ) ;
కోసం ( int a = 0 ; a < = 456450 ; a++ ) ;
ticks_end = గడియారం ( ) ; // కొలత స్టాప్
పేలు = ticks_end - ticks_ini;
printf ( 'టిక్స్ ఎండ్ కొలత %ld \n ' , టిక్స్_ఎండ్ ) ;
printf ( 'కొలత %f మధ్య టిక్‌లు గడిచిపోయాయి \n ' , పేలు ) ;
తిరిగి ;
}
మొదట, మేము రెండు వేరియబుల్స్ సృష్టిస్తాము, పేలు_ఇని మరియు పేలు_ముగింపు , దీనిలో మేము గడియారం() ఫలితాన్ని దాని రెండు కాల్‌లలో నిల్వ చేస్తాము. గడిచిన టిక్‌ల సంఖ్య మరియు పూర్ణాంకాన్ని పొందడానికి మేము దానిని గణిస్తాము పేలు , దీనిలో మేము మొత్తం గడిచిన పేలుల తుది ఫలితాన్ని నిల్వ చేస్తాము.
అప్పుడు, మేము కాల్ గడియారం() మా 'మెయిన్'లో పని చేస్తుంది మరియు గతంలో నిర్వచించిన క్లాక్ టిక్‌లను తిరిగి పొందండి పేలు_ఇని ప్రోగ్రామ్ ప్రారంభమైనప్పటి నుండి ఈ ఫంక్షన్‌కు మొదటి కాల్ వరకు గడిచిన వేరియబుల్. ఈ విలువను ప్రదర్శించడానికి మేము printf() ఫంక్షన్‌ని ఉపయోగిస్తాము.
మేము సృష్టించిన ఈ ఆలస్యం తర్వాత కోసం , మేము కాల్ గడియారం() ఈ పాయింట్ వరకు టిక్‌ల సంఖ్యను పొందడానికి రెండవ సారి ఫంక్షన్ చేయండి. మేము printf() ఫంక్షన్‌తో ఫలితాన్ని స్క్రీన్‌కు అవుట్‌పుట్ చేస్తాము. మొదటి మరియు రెండవ కాల్‌ల మధ్య గడిచిన టిక్‌ల ఖచ్చితమైన సంఖ్య ఫలితాన్ని మేము పొందుతాము గడియారం() తీసివేయడం ద్వారా పేలు_ఇని నుండి పేలు_ముగింపు మరియు మేము printf()తో కన్సోల్‌కు అవుట్‌పుట్ చేసే వేరియబుల్ టిక్‌లలో ఫలితాన్ని నిల్వ చేస్తాము.
ఈ విధంగా, మేము కోడ్‌లో ఒక పాయింట్ నుండి మరొక పాయింట్‌కి గడిచిన టిక్‌లను పొందుతాము.
క్లాక్() ఫంక్షన్‌తో పొందిన టిక్‌ల సంఖ్యను సెకన్లకు ఎలా మార్చాలి
ప్రోగ్రామ్ ప్రారంభమైనప్పటి నుండి లేదా ఒక పాయింట్ నుండి మరొక పాయింట్‌కు గడిచిన టిక్‌ల సంఖ్యను కలిగి ఉన్న తర్వాత, మునుపటి ఉదాహరణ ఫలితాన్ని time.hలో ముందే నిర్వచించబడిన స్థిరాంకంతో భాగించడం ద్వారా మనం ఈ సమయాన్ని టిక్‌లలో వ్యక్తీకరించిన సెకన్లకు మార్చవచ్చు. CLOCKS _PER_ SEC, కింది స్నిప్పెట్‌లో చూపిన విధంగా:
పేలు = ( ticks_end - ticks_ini ) / ( రెట్టింపు ) CLOCKS_PER_SEC;printf ( 'కొలత %f మధ్య టిక్‌లు సెకన్లలో గడిచిపోయాయి \n ' , పేలు ) ;
ముగింపు
ఇందులో Linux సూచన వ్యాసం, ఎలా అమలు చేయాలో మేము మీకు చూపించాము గడియారం() సిస్టమ్ గడియారం యొక్క టిక్‌లలో సమయ కొలతలను చేయడానికి ఫంక్షన్. నడుస్తున్న అప్లికేషన్‌లో మీరు ఈ సమయాలను మొత్తం లేదా కొంత భాగాన్ని ఎలా కొలవగలరో కూడా మేము వివరించాము. ఫలితాలను సెకన్లకు ఎలా మార్చాలో మేము మీకు చూపించాము. ఈ వ్యాసం మీకు ఉపయోగకరంగా ఉందని మేము ఆశిస్తున్నాము. మీరు వెబ్‌సైట్ శోధన ఇంజిన్‌ని ఉపయోగించి కనుగొనగలిగే మా కథనాలలో C భాష గురించి మరిన్ని చిట్కాలను కనుగొనవచ్చు.