இந்த கட்டுரையில், எங்கள் சி திட்டத்தில் உண்மையான வேலை செய்ய உண்மையான கணினி அழைப்புகளைப் பயன்படுத்தப் போகிறோம். முதலில், நீங்கள் கணினி அழைப்பைப் பயன்படுத்த வேண்டுமா என்பதை நாங்கள் மதிப்பாய்வு செய்வோம், பின்னர் கோப்பு நகல் செயல்திறனை வியத்தகு முறையில் மேம்படுத்தக்கூடிய அனுப்பும் கோப்பு () அழைப்பைப் பயன்படுத்தி ஒரு உதாரணத்தை வழங்குகிறோம். இறுதியாக, லினக்ஸ் சிஸ்டம் அழைப்புகளைப் பயன்படுத்தும் போது நாம் நினைவில் கொள்ள வேண்டிய சில புள்ளிகளுக்குச் செல்வோம்.
இது தவிர்க்க முடியாதது என்றாலும், உங்கள் சி மேம்பாட்டு வாழ்க்கையின் ஒரு கட்டத்தில் நீங்கள் ஒரு கணினி அழைப்பைப் பயன்படுத்துவீர்கள், நீங்கள் உயர் செயல்திறன் அல்லது ஒரு குறிப்பிட்ட வகை செயல்பாட்டை இலக்காகக் கொள்ளாவிட்டால், முக்கிய லினக்ஸ் விநியோகங்களில் சேர்க்கப்பட்டுள்ள கிளிபிக் நூலகம் மற்றும் பிற அடிப்படை நூலகங்கள் பெரும்பான்மையைக் கவனித்துக்கொள்ளும். உங்கள் தேவைகள்.
Glibc தரமான நூலகம் ஒரு குறுக்கு தளத்தை வழங்குகிறது, இல்லையெனில் கணினி-குறிப்பிட்ட கணினி அழைப்புகள் தேவைப்படும் செயல்பாடுகளை செயல்படுத்த நன்கு சோதிக்கப்பட்ட கட்டமைப்பை வழங்குகிறது. உதாரணமாக, நீங்கள் ஒரு கோப்பை fscanf (), fread (), getc (), முதலியவற்றைப் படிக்கலாம் அல்லது படிக்க () லினக்ஸ் கணினி அழைப்பைப் பயன்படுத்தலாம். Glibc செயல்பாடுகள் அதிக அம்சங்களை வழங்குகின்றன (அதாவது சிறந்த பிழை கையாளுதல், வடிவமைக்கப்பட்ட IO, முதலியன) மற்றும் எந்த கணினி glibc ஆதரவிலும் வேலை செய்யும்.
மறுபுறம், சமரசமற்ற செயல்திறன் மற்றும் சரியான மரணதண்டனை முக்கியமான நேரங்கள் உள்ளன. ஃப்ரெட் () வழங்கும் மடக்கு மேல்நிலை சேர்க்கும், மற்றும் சிறியதாக இருந்தாலும், முற்றிலும் வெளிப்படையானது அல்ல. கூடுதலாக, ரேப்பர் வழங்கும் கூடுதல் அம்சங்களை நீங்கள் விரும்பவோ அல்லது தேவைப்படவோ கூடாது. அப்படியானால், நீங்கள் ஒரு கணினி அழைப்புடன் சிறப்பாக சேவை செய்யப்படுவீர்கள்.
Glibc ஆல் ஆதரிக்கப்படாத செயல்பாடுகளைச் செய்ய நீங்கள் கணினி அழைப்புகளையும் பயன்படுத்தலாம். உங்கள் glibc நகல் புதுப்பித்த நிலையில் இருந்தால், இது ஒரு பிரச்சினையாக இருக்காது, ஆனால் பழைய கர்னல்களுடன் பழைய விநியோகங்களில் வளர்வதற்கு இந்த நுட்பம் தேவைப்படலாம்.
இப்போது நீங்கள் மறுப்புகள், எச்சரிக்கைகள் மற்றும் சாத்தியமான மாற்றுப்பாதைகளைப் படித்திருக்கிறீர்கள், இப்போது சில நடைமுறை எடுத்துக்காட்டுகளைப் பார்ப்போம்.
நாம் என்ன CPU இல் இருக்கிறோம்?
பெரும்பாலான நிரல்கள் கேட்க விரும்பாத ஒரு கேள்வி, ஆனால் ஒரு செல்லுபடியாகும் கேள்வி. இது glibc உடன் நகலெடுக்க முடியாத மற்றும் ஒரு glibc போர்வையால் மூடப்படாத ஒரு கணினி அழைப்பின் எடுத்துக்காட்டு. இந்த குறியீட்டில், சிஸ்கால் () செயல்பாடு வழியாக நேரடியாக getcpu () அழைப்பை அழைப்போம். சிஸ்கால் செயல்பாடு பின்வருமாறு செயல்படுகிறது:
சிஸ்கால்(SYS_ அழைப்பு,arg1,arg2,...);முதல் வாதம், SYS_call, கணினி அழைப்பின் எண்ணிக்கையைக் குறிக்கும் ஒரு வரையறை. நீங்கள் sys/syscall.h ஐ சேர்க்கும்போது, இவை சேர்க்கப்படும். முதல் பகுதி SYS_ மற்றும் இரண்டாவது பகுதி கணினி அழைப்பின் பெயர்.
அழைப்பிற்கான வாதங்கள் மேலே arg1, arg2 க்கு செல்கின்றன. சில அழைப்புகளுக்கு அதிக வாதங்கள் தேவைப்படுகின்றன, மேலும் அவை அவற்றின் மேன் பக்கத்திலிருந்து வரிசையில் தொடரும். பெரும்பாலான வாதங்கள், குறிப்பாக வருமானத்திற்கு, சுட்டிகள் வரிசைகள் அல்லது மல்லாக் செயல்பாட்டின் மூலம் ஒதுக்கப்பட்ட நினைவகத்தை சார்ஜ் செய்ய வேண்டும் என்பதை நினைவில் கொள்ளுங்கள்.
உதாரணம் 1. சி
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
intமுக்கிய() {
கையொப்பமிடாதcpu,முனை;
// கணினி அழைப்பு மூலம் தற்போதைய CPU கோர் மற்றும் NUMA முனை கிடைக்கும்
// இதற்கு கிளிபிக் ரேப்பர் இல்லை என்பதை நினைவில் கொள்ளவும், எனவே நாம் அதை நேரடியாக அழைக்க வேண்டும்
சிஸ்கால்(SYS_getcpu, &cpu, &முனை,ஏதுமில்லை);
// காட்சி தகவல்
printf (இந்த திட்டம் CPU கோர் %u மற்றும் NUMA முனை %u இல் இயங்குகிறது. n n',cpu,முனை);
திரும்ப 0;
}
தொகுத்து இயக்க:
gcc உதாரணம் 1.c -உதாரணம் 1
./உதாரணம் 1
மேலும் சுவாரஸ்யமான முடிவுகளுக்கு, நீங்கள் pthreads நூலகம் வழியாக நூல்களைச் சுழற்றலாம், பின்னர் உங்கள் நூல் எந்த செயலியில் இயங்குகிறது என்பதைப் பார்க்க இந்த செயல்பாட்டை அழைக்கலாம்.
Sendfile: உயர்ந்த செயல்திறன்
கணினி அழைப்புகள் மூலம் செயல்திறனை மேம்படுத்துவதற்கான சிறந்த உதாரணத்தை Sendfile வழங்குகிறது. அனுப்பு கோப்பு () செயல்பாடு தரவை ஒரு கோப்பு விவரிப்பாளரிடமிருந்து மற்றொன்றுக்கு நகலெடுக்கிறது. பல ஃப்ரெட் () மற்றும் ஃப்ரைட் () செயல்பாடுகளைப் பயன்படுத்துவதற்குப் பதிலாக, செண்ட்ஃபைல் கர்னல் இடத்தில் பரிமாற்றத்தைச் செய்கிறது, மேல்நிலைப்பாட்டைக் குறைத்து அதன் மூலம் செயல்திறனை அதிகரிக்கும்.
இந்த எடுத்துக்காட்டில், 64 எம்பி தரவை ஒரு கோப்பிலிருந்து இன்னொரு கோப்பிற்கு நகலெடுக்கப் போகிறோம். ஒரு சோதனையில், நிலையான நூலகத்தில் நிலையான படிக்க/எழுதும் முறைகளைப் பயன்படுத்தப் போகிறோம். மற்றொன்றில், இந்த தரவை ஒரு இடத்திலிருந்து இன்னொரு இடத்திற்கு வெடிக்க நாங்கள் கணினி அழைப்புகள் மற்றும் அனுப்பு கோப்பு () அழைப்பைப் பயன்படுத்துவோம்.
test1.c (glibc)
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#BUFFER_SIZE 67108864 ஐ வரையறுக்கவும்
#BUFFER_1 'buffer1' ஐ வரையறுக்கவும்
#BUFFER_2 'இடையக 2' ஐ வரையறுக்கவும்
intமுக்கிய() {
கோப்பு*தவறு, *முடிவு;
printf (' nபாரம்பரிய Glibc செயல்பாடுகளுடன் I/O சோதனை. n n');
// ஒரு BUFFER_SIZE இடையகத்தைப் பிடிக்கவும்.
// இடையகத்தில் சீரற்ற தரவு இருக்கும் ஆனால் நாங்கள் அதைப் பொருட்படுத்தவில்லை.
printf ('64 எம்பி இடையகத்தை ஒதுக்குதல்:');
கரி *இடையகம்= (கரி *) மல்லோக் (BUFFER_SIZE);
printf ('முடிந்தது n');
// இடையகத்தை fOut என எழுதுங்கள்
printf ('முதல் இடையகத்திற்கு தரவை எழுதுதல்:');
தவறு= fopen (இடையகம், 'wb');
fwrite (இடையகம், அளவு(கரி),BUFFER_SIZE,தவறு);
fclose (தவறு);
printf ('முடிந்தது n');
printf ('முதல் கோப்பிலிருந்து இரண்டாவது கோப்புக்கு தரவை நகலெடுக்கிறது:');
முடிவு= fopen (இடையகம், 'ஆர்பி');
தவறு= fopen (BUFFER_2, 'wb');
fread (இடையகம், அளவு(கரி),BUFFER_SIZE,முடிவு);
fwrite (இடையகம், அளவு(கரி),BUFFER_SIZE,தவறு);
fclose (முடிவு);
fclose (தவறு);
printf ('முடிந்தது n');
printf ('இடையகத்தை விடுவித்தல்:');
இலவசம் (இடையகம்);
printf ('முடிந்தது n');
printf ('கோப்புகளை நீக்குகிறது:');
அகற்று (இடையகம்);
அகற்று (BUFFER_2);
printf ('முடிந்தது n');
திரும்ப 0;
}
test2.c (கணினி அழைப்புகள்)
#சேர்க்கிறது#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#சேர்க்கிறது
#BUFFER_SIZE 67108864 ஐ வரையறுக்கவும்
intமுக்கிய() {
intதவறு,முடிவு;
printf (' nஅனுப்பு கோப்பு () மற்றும் தொடர்புடைய கணினி அழைப்புகளுடன் I/O சோதனை. n n');
// ஒரு BUFFER_SIZE இடையகத்தைப் பிடிக்கவும்.
// இடையகத்தில் சீரற்ற தரவு இருக்கும் ஆனால் நாங்கள் அதைப் பொருட்படுத்தவில்லை.
printf ('64 எம்பி இடையகத்தை ஒதுக்குதல்:');
கரி *இடையகம்= (கரி *) மல்லோக் (BUFFER_SIZE);
printf ('முடிந்தது n');
// இடையகத்தை fOut என எழுதுங்கள்
printf ('முதல் இடையகத்திற்கு தரவை எழுதுதல்:');
தவறு=திற('இடையகம் 1',O_RDONLY);
எழுது(தவறு, &இடையகம்,BUFFER_SIZE);
நெருக்கமான(தவறு);
printf ('முடிந்தது n');
printf ('முதல் கோப்பிலிருந்து இரண்டாவது கோப்புக்கு தரவை நகலெடுக்கிறது:');
முடிவு=திற('இடையகம் 1',O_RDONLY);
தவறு=திற('தாங்கல் 2',O_RDONLY);
கோப்பு அனுப்பவும்(தவறு,முடிவு, 0,BUFFER_SIZE);
நெருக்கமான(முடிவு);
நெருக்கமான(தவறு);
printf ('முடிந்தது n');
printf ('இடையகத்தை விடுவித்தல்:');
இலவசம் (இடையகம்);
printf ('முடிந்தது n');
printf ('கோப்புகளை நீக்குகிறது:');
இணைப்பை நீக்கவும்('இடையகம் 1');
இணைப்பை நீக்கவும்('தாங்கல் 2');
printf ('முடிந்தது n');
திரும்ப 0;
}
1 & 2 தேர்வுகளைத் தொகுத்தல் மற்றும் இயக்குதல்
இந்த எடுத்துக்காட்டுகளை உருவாக்க, உங்கள் விநியோகத்தில் நிறுவப்பட்ட மேம்பாட்டு கருவிகள் உங்களுக்குத் தேவைப்படும். டெபியன் மற்றும் உபுண்டுவில், இதை இதை நிறுவலாம்:
பொருத்தமானநிறுவுகட்டமைப்பு-அத்தியாவசியங்கள்பின் இதனுடன் தொகுக்க:
gccசோதனை 1. சி-அல்லதுசோதனை 1&& gccசோதனை 2. சி-அல்லதுசோதனை 2இரண்டையும் இயக்க மற்றும் செயல்திறனை சோதிக்க, இயக்கவும்:
நேரம்./சோதனை 1&& நேரம்./சோதனை 2இது போன்ற முடிவுகளை நீங்கள் பெற வேண்டும்:
பாரம்பரிய Glibc செயல்பாடுகளுடன் I/O சோதனை.
64 எம்பி இடையகத்தை ஒதுக்குதல்: முடிந்ததுமுதல் இடையகத்திற்கு தரவை எழுதுதல்: முடிந்தது
முதல் கோப்பிலிருந்து இரண்டாவது கோப்புக்கு தரவை நகலெடுக்கிறது: முடிந்தது
இடையகத்தை விடுவித்தல்: முடிந்தது
கோப்புகளை நீக்குகிறது: முடிந்தது
உண்மையான 0m0.397s
பயனர் 0m0.000s
sys 0m0.203s
அனுப்பு கோப்பு () மற்றும் தொடர்புடைய கணினி அழைப்புகளுடன் I/O சோதனை.
64 எம்பி இடையகத்தை ஒதுக்குதல்: முடிந்தது
முதல் இடையகத்திற்கு தரவை எழுதுதல்: முடிந்தது
முதல் கோப்பிலிருந்து இரண்டாவது கோப்புக்கு தரவை நகலெடுக்கிறது: முடிந்தது
இடையகத்தை விடுவித்தல்: முடிந்தது
கோப்புகளை நீக்குகிறது: முடிந்தது
உண்மையான 0m0.019s
பயனர் 0m0.000s
sys 0m0.016s
நீங்கள் பார்க்க முடியும் என, கணினி அழைப்புகளை பயன்படுத்தும் குறியீடு glibc சமமானதை விட மிக வேகமாக இயங்குகிறது.
நினைவில் கொள்ள வேண்டிய விஷயங்கள்
கணினி அழைப்புகள் செயல்திறனை அதிகரிக்கலாம் மற்றும் கூடுதல் செயல்பாட்டை வழங்கலாம், ஆனால் அவை தீமைகள் இல்லாமல் இல்லை. பிளாட்பார்ம் பெயர்வுத்திறன் மற்றும் சில நேரங்களில் நூலக செயல்பாடுகளுடன் ஒப்பிடும்போது குறைக்கப்பட்ட செயல்பாட்டிற்கு எதிராக கணினி அழைப்புகள் வழங்கும் நன்மைகளை நீங்கள் எடைபோட வேண்டும்.
சில கணினி அழைப்புகளைப் பயன்படுத்தும் போது, நூலகச் செயல்பாடுகளைக் காட்டிலும் கணினி அழைப்புகளிலிருந்து திரும்பப் பெறும் வளங்களைப் பயன்படுத்த நீங்கள் கவனமாக இருக்க வேண்டும். எடுத்துக்காட்டாக, glibc இன் fopen (), fread (), fwrite (), மற்றும் fclose () செயல்பாடுகளுக்குப் பயன்படுத்தப்படும் FILE அமைப்பு திறந்த () கணினி அழைப்பிலிருந்து (முழு எண்ணாகத் திரும்பிய) கோப்பு விளக்க எண் போன்றது அல்ல. இவற்றைக் கலப்பது சிக்கல்களுக்கு வழிவகுக்கும்.
பொதுவாக, லினக்ஸ் கணினி அழைப்புகள் glibc செயல்பாடுகளை விட குறைவான பம்பர் பாதைகளைக் கொண்டுள்ளன. கணினி அழைப்புகளில் சில பிழை கையாளுதல் மற்றும் அறிக்கையிடல் உள்ளது என்பது உண்மை என்றாலும், நீங்கள் ஒரு glibc செயல்பாட்டிலிருந்து இன்னும் விரிவான செயல்பாட்டைப் பெறுவீர்கள்.
இறுதியாக, பாதுகாப்பு பற்றிய ஒரு வார்த்தை. கணினி அழைப்புகள் நேரடியாக கர்னலுடன் இடைமுகம். லினக்ஸ் கர்னல் பயனர் நிலத்திலிருந்து ஷெனனிகன்களுக்கு எதிராக விரிவான பாதுகாப்புகளைக் கொண்டுள்ளது, ஆனால் கண்டுபிடிக்கப்படாத பிழைகள் உள்ளன. ஒரு கணினி அழைப்பு உங்கள் உள்ளீட்டைச் சரிபார்க்கும் அல்லது பாதுகாப்பு சிக்கல்களிலிருந்து உங்களை தனிமைப்படுத்தும் என்று நம்ப வேண்டாம். கணினி அழைப்பிற்கு நீங்கள் கொடுக்கும் தரவு சுத்திகரிக்கப்பட்டிருப்பதை உறுதி செய்வது புத்திசாலித்தனம். இயற்கையாகவே, எந்தவொரு API அழைப்பிற்கும் இது நல்ல ஆலோசனையாகும், ஆனால் கர்னலுடன் பணிபுரியும் போது நீங்கள் கவனமாக இருக்க முடியாது.
லினக்ஸ் சிஸ்டம் அழைப்புகளின் நிலத்தில் நீங்கள் இந்த ஆழமான டைவ் அனுபவித்தீர்கள் என்று நம்புகிறேன். லினக்ஸ் கணினி அழைப்புகளின் முழு பட்டியலுக்கு, எங்கள் முதன்மை பட்டியலைப் பார்க்கவும்.