இதில் லினக்ஸ் குறிப்பு கட்டுரையில், அதை எவ்வாறு பயன்படுத்துவது என்பதை நாங்கள் உங்களுக்குக் காண்பிப்போம் கடிகாரம் () செயல்பாடு, ஒரு குறிப்பிட்ட செயல்முறை அல்லது நூலின் செயல்பாட்டு நேரத்தை அளவிடுவதற்கு, C மொழியில் கிடைக்கும் ஆதாரங்களில் ஒன்றாகும்.
நேரத்தின் இந்த பகுதிகள் முக்கியமற்றதாகத் தோன்றினாலும், இந்த சிறிய பகுதிகளை அளவிடும் மற்றும் கணக்கிடும் திறன் அமைப்பு அல்லது செயல்முறையின் துல்லியத்தில் முக்கியமான காரணிகளாக இருக்கும் முக்கியமான நிகழ்வுகள் உள்ளன. எப்படி என்பதற்கான தத்துவார்த்த விளக்கத்தை நாங்கள் தருவோம் கடிகாரம் () வேலை செய்கிறது, அதன் செயல்பாடு மற்றும் இந்த நோக்கத்திற்காக அது பயன்படுத்தும் அளவீட்டு அலகுகளை விளக்குகிறது.
பின்னர், குறியீட்டு துண்டுகள் மற்றும் படங்களை உள்ளடக்கிய நடைமுறை எடுத்துக்காட்டுகளைப் பயன்படுத்தி, வெவ்வேறு அமைப்புகளில் நிகழ்நேர செயல்முறைகளில் முக்கியமான நேரங்களை அளவிடுவதற்கு தெளிவான மற்றும் விரிவான முறையில் இந்த செயல்பாட்டை எவ்வாறு செயல்படுத்தலாம் என்பதைப் பார்ப்போம்.
கடிகாரம்() செயல்பாடு தொடரியல்:
கடிகாரம்_t கடிகாரம் ( வெற்றிடமானது )
C மொழியில் கடிகாரம்() செயல்பாடு விளக்கம்
அழைக்கப்படும் போது கடிகாரம்() செயல்பாடு காலியாக உள்ளது. இதில் உள்ளீட்டு வாதங்கள் எதுவும் இல்லை மற்றும் அழைப்பின் போது 'clock_t' இல் கடிகாரத்தின் டிக் எண்ணிக்கையை வழங்கும்.
பயன்பாடு தொடங்கும் போது துடிப்பு எண்ணிக்கை பூஜ்ஜியத்தில் தொடங்கி, பயனர் அல்லது கணினி வெளியேறும் வரை தொடர்கிறது, தோராயமாக ஒவ்வொரு 72 நிமிடங்களிலும் பூஜ்ஜியத்திற்கு மீட்டமைக்கப்படும். கடிகாரம்() செயல்பாடு இந்த கவுண்டரின் மீது மாற்றமோ அல்லது கட்டுப்பாட்டையோ கொண்டிருக்கவில்லை; அழைக்கும் போது மட்டுமே அதன் மதிப்பு கிடைக்கும்.
நிரலின் மொத்த செயலாக்க நேரத்தை அளவிட, நிரலின் முடிவில் கடிகாரத்தை () ஒரு முறை மட்டுமே அழைக்க வேண்டும். நிரலின் ஒரு புள்ளியில் இருந்து மற்றொன்றுக்கு கழிந்த நேரத்தை அளவிட, நாம் கடிகாரம்( ) செயல்பாட்டை அழைக்க வேண்டும் மற்றும் பெறப்பட்ட இரண்டு தரவை கணக்கிட வேண்டும்.
இரண்டு அழைப்புகளுக்கு இடையில் கழிந்த உண்ணிகளை தீர்மானிக்க கணக்கீடு கடிகாரம் () இரண்டாவது அழைப்பின் முடிவிலிருந்து முதல் அழைப்பின் முடிவைக் கழிப்பதன் மூலம் செயல்பாடு செய்யப்படுகிறது. நிரலின் ஒரு புள்ளியிலிருந்து மற்றொரு இடத்திற்கு கழிந்த நேரத்தின் அளவைத் தீர்மானிக்க ஒரு உதாரணத்தைப் பார்ப்போம்.
தி கடிகாரம் () செயல்பாடு 'time.h' தலைப்பு செயல்பாடுகளில் வரையறுக்கப்படுகிறது. அதைப் பயன்படுத்த, பின்வரும் படத்தில் காட்டப்பட்டுள்ளபடி, நமது '.c' அல்லது '.h' குறியீட்டு கோப்பில் சேர்க்க வேண்டும்.
#அடங்கும்கடிகாரம்() செயல்பாட்டின் மூலம் நிரலில் ஒரு புள்ளியில் இருந்து மற்றொரு புள்ளிக்கு கடந்த கடிகார டிக்களை எவ்வாறு பெறுவது
இந்த எடுத்துக்காட்டில், நிரலில் ஒரு புள்ளியில் இருந்து மற்றொரு புள்ளியில் கழிந்த உண்ணிகளின் எண்ணிக்கையை எவ்வாறு பெறுவது என்று பார்ப்போம். இந்த இரண்டு புள்ளிகளும் இரண்டு அழைப்புகளில் ஒன்றுக்கு ஒத்திருக்கும் கடிகாரம் () செயல்பாடு, முறையே. இதைப் புரிந்து கொள்ள, பின்வரும் குறியீட்டைப் பார்ப்போம்:
#
#அடங்கும்
வெற்றிட முக்கிய ( )
{
கடிகாரம்_டி டிக்ஸ்_இனி, டிக்ஸ்_எண்ட்;
இரட்டை உண்ணி;
ticks_ini = கடிகாரம் ( ) ; // தொடக்கத்தை அளவிடவும்
printf ( 'டிக்கள் init அளவீடு %ld \n ' , உண்ணி_இனி ) ;
க்கான ( முழு எண்ணாக அ = 0 ; அ < = 456450 ; a++ ) ;
ticks_end = கடிகாரம் ( ) ; // நிறுத்தத்தை அளவிடவும்
உண்ணி = ticks_end - ticks_ini;
printf ( 'டிக்ஸ் எண்ட் அளவீடு %ld \n ' , உண்ணி_முடிவு ) ;
printf ( '% f அளவீடுகளுக்கு இடையே உண்ணிகள் கடந்துவிட்டன \n ' , உண்ணி ) ;
திரும்ப ;
}
முதலில், நாம் இரண்டு மாறிகளை உருவாக்குகிறோம், உண்ணி_இனி மற்றும் உண்ணி_முடிவு , இதில் கடிகாரத்தின் () முடிவை அதன் இரண்டு அழைப்புகளில் சேமிக்கிறோம். கழிந்த உண்ணிகளின் எண்ணிக்கையையும் முழு எண்ணையும் பெற அதைக் கணக்கிடுகிறோம் உண்ணி , இதில் மொத்த கழிந்த உண்ணிகளின் இறுதி முடிவை சேமித்து வைக்கிறோம்.
பின்னர், நாம் அழைக்கிறோம் கடிகாரம் () எங்கள் 'முக்கிய' இல் செயல்படும் மற்றும் முன்பு வரையறுக்கப்பட்ட கடிகார உண்ணிகளை மீட்டெடுக்கவும் உண்ணி_இனி நிரலின் தொடக்கத்திலிருந்து இந்தச் செயல்பாட்டிற்கான முதல் அழைப்பு வரையிலான மாறி. இந்த மதிப்பைக் காட்ட printf() செயல்பாட்டைப் பயன்படுத்துகிறோம்.
இந்த தாமதத்திற்குப் பிறகு, நாங்கள் உருவாக்கியுள்ளோம் க்கான , நாம் அழைக்கிறோம் கடிகாரம் () இந்த புள்ளி வரை உண்ணி எண்ணிக்கை பெற இரண்டாவது முறையாக செயல்பட. முடிவை நாம் printf() செயல்பாட்டின் மூலம் திரையில் வெளியிடுகிறோம். முதல் மற்றும் இரண்டாவது அழைப்புகளுக்கு இடையில் கழிந்த உண்ணிகளின் சரியான எண்ணிக்கையின் முடிவைப் பெறுகிறோம் கடிகாரம் () கழிப்பதன் மூலம் உண்ணி_இனி இருந்து உண்ணி_முடிவு மற்றும் முடிவை மாறி உண்ணிகளில் சேமிக்கிறோம், அதை நாம் printf() உடன் கன்சோலுக்கு வெளியிடுகிறோம்.
இந்த வழியில், குறியீட்டில் ஒரு புள்ளியில் இருந்து மற்றொரு இடத்திற்கு கடந்து செல்லும் உண்ணிகளைப் பெறுகிறோம்.
கடிகாரம்() செயல்பாட்டின் மூலம் பெறப்பட்ட டிக்களின் எண்ணிக்கையை வினாடிகளாக மாற்றுவது எப்படி
நிரல் தொடங்கியதில் இருந்து அல்லது ஒரு புள்ளியில் இருந்து மற்றொரு புள்ளியில் உள்ள டிக்களின் எண்ணிக்கையை நாம் பெற்றவுடன், முந்தைய எடுத்துக்காட்டின் முடிவை time.h இன் முன் வரையறுக்கப்பட்ட மாறிலியால் வகுப்பதன் மூலம் இந்த நேரத்தை உண்ணிகளில் வெளிப்படுத்திய நேரத்தை வினாடிகளாக மாற்றலாம். CLOCKS _PER_ SEC, பின்வரும் துணுக்கில் காட்டப்பட்டுள்ளபடி:
உண்ணி = ( உண்ணி_முடிவு - உண்ணி_இனி ) / ( இரட்டை ) CLOCKS_PER_SEC;printf ( 'உண்ணிகள் %f அளவுகளுக்கு இடையே நொடிகளில் கழிந்தன \n ' , உண்ணி ) ;
முடிவுரை
இதில் லினக்ஸ் குறிப்பு கட்டுரையில், அதை எவ்வாறு செயல்படுத்துவது என்பதை நாங்கள் உங்களுக்குக் காண்பித்தோம் கடிகாரம் () கணினி கடிகாரத்தின் டிக்களில் நேர அளவீடுகளைச் செய்வதற்கான செயல்பாடு. இயங்கும் பயன்பாட்டிற்குள் இந்த நேரங்கள் அனைத்தையும் அல்லது பகுதியை நீங்கள் எவ்வாறு அளவிடலாம் என்பதையும் நாங்கள் விளக்கினோம். முடிவுகளை வினாடிகளுக்கு மாற்றுவது எப்படி என்பதை நாங்கள் உங்களுக்குக் காண்பித்தோம். இந்த கட்டுரை உங்களுக்கு பயனுள்ளதாக இருந்தது என்று நம்புகிறோம். வலைத்தளத்தின் தேடுபொறியைப் பயன்படுத்தி நீங்கள் கண்டுபிடிக்கக்கூடிய எங்கள் கட்டுரைகளில் C மொழியைப் பற்றிய கூடுதல் உதவிக்குறிப்புகளைக் காணலாம்.