yes கட்டளையை இயக்குவது ஏன் CPU பயன்பாட்டை உச்சநிலைக்குக் கொண்டு செல்லவில்லை

yes கட்டளையை இயக்குவது ஏன் CPU பயன்பாட்டை உச்சநிலைக்குக் கொண்டு செல்லவில்லை

Linux சர்வர்களில் CPU சுமையைப் புரிந்துகொள்ளுதல்

ஒரு Linux சர்வரில் CPU சுமையைச் சோதிக்க முயற்சிக்கும்போது, பலர் இந்த yes கட்டளையை இயக்குவது ஒரு விரைவான தீர்வு என்று நினைக்கலாம். ஆனால் நான் சமீபத்தில் கண்டறிந்தபடி, இது எப்போதும் எதிர்பார்த்தபடி செயல்படுவதில்லை. சர்வர்கள் அல்லது செயல்திறன் சோதனையுடன் பணிபுரியும் எவருக்கும் இந்தத் தலைப்பைப் புரிந்துகொள்வது முக்கியமாகும்.

yes கட்டளை என்றால் என்ன?

இந்த yes கட்டளையானது Linux-ல் ஒரு சரத்தை மீண்டும் மீண்டும் வெளியிடும் ஒரு எளிய பயன்பாடாகும். முன்னிருப்பாக, இது "y" என்பதை முடிவில்லாமல் வெளியிடுகிறது. இது ஒரு முடிவிலா சுழற்சியில் இயங்குவதால், CPU சுமையை உருவாக்குவதற்கு மிகவும் பொருத்தமான ஒன்றாகத் தோன்றுகிறது.

எனது பரிசோதனை

நான் கட்டளையை இவ்வாறு இயக்கினேன்:

yes > /dev/null

இந்தக் கட்டளையானது yes -ன் முடிவில்லா வெளியீட்டை /dev/null-க்கு அனுப்புகிறது, அதாவது இது வெளியீட்டை நிராகரிக்கிறது. இந்தக் கட்டளையை இயக்குவது CPU பயன்பாட்டை உச்சநிலைக்குக் கொண்டு செல்லும் என்று கருதப்பட்டது. இருப்பினும், இதன் முடிவுகள் எனக்கு ஆச்சரியத்தை அளித்தன.

CPU பயன்பாட்டைக் கவனித்தல்

கட்டளையை இயக்கிய பிறகு, நான் CPU பயன்பாட்டை இந்த top கட்டளை மூலம் சரிபார்த்தேன். நான் கண்டது இங்கே:

%Cpu(s): 29.8 us, 20.2 sy, 0.0 ni, 49.4 id, 0.0 wa, 0.0 hi, 0.7 si, 0.0 st
%Cpu0  : 0.0 us, 0.0 sy, 0.0 ni, 99.7 id, 0.0 wa, 0.0 hi, 0.3 si, 0.0 st
%Cpu1  : 64.1 us, 35.9 sy, 0.0 ni, 0.0 id, 0.0 wa, 0.0 hi, 0.0 si, 0.0 st

இந்த yes செயல்முறை CPU1-ன் 100% பயன்பாட்டில் இருப்பதாகக் காட்டப்பட்டாலும், ஒட்டுமொத்த CPU பயன்பாடு சுமார் 50% மட்டுமே இருந்தது. இது எதிர்பாராத ஒன்று.

இது ஏன் CPU பயன்பாட்டை உச்சநிலைக்குக் கொண்டு செல்லவில்லை?

இந்த நடத்தைக்கான முக்கிய காரணம் என்னவென்றால், yes கட்டளையானது ஒரு ஒற்றை-இழை செயல்முறை. இதன் பொருள், இது ஒரு நேரத்தில் ஒரு CPU கோரில் மட்டுமே இயங்க முடியும் என்பதாகும். எனது விஷயத்தில், சர்வரில் இரண்டு கோர்கள் இருந்தன:

  • CPU0 கிட்டத்தட்ட 100% செயலற்ற நேரத்துடன், பெரும்பாலும் செயலற்றதாக இருந்தது.
  • CPU1 அதிகப் பயன்பாட்டைக் காட்டி, தீவிரமாக இயங்கிக் கொண்டிருந்தது.

எனவே, நான் இந்த yes-ன் ஒரு நிகழ்வை இயக்கியபோது, அது ஒரு கோரை முழுமையாகப் பயன்படுத்தியது, ஆனால் மற்றொரு கோரைப் பயன்படுத்தாமல் விட்டது. எனவே, ஒட்டுமொத்த CPU பயன்பாடு சுமார் 50% ஆக இருந்தது.

100% ஒட்டுமொத்த CPU பயன்பாட்டை அடைவது எப்படி

இரண்டு CPU கோர்களையும் திறம்படப் பயன்படுத்த, நான் இந்த yes கட்டளையின் பல நிகழ்வுகளை இயக்க வேண்டியிருந்தது. அதை நீங்கள் எவ்வாறு செய்யலாம் என்பது இங்கே:

படி 1: உங்கள் டெர்மினலைத் திறக்கவும்.

படி 2: பின்வரும் கட்டளையை இயக்கவும்:

for i in $(seq $(nproc)); do yes > /dev/null & done

இந்தக் கட்டளை உங்கள் சர்வரில் கிடைக்கும் ஒவ்வொரு CPU கோருக்கும் ஒரு புதிய yes செயல்முறையை உருவாக்குகிறது. இது பின்னணியில் yes -ஐ இயக்கும் ஒரு எளிய லூப் ஆகும்.

படி 3: மீண்டும் CPU பயன்பாட்டை இந்த top கட்டளை மூலம் சரிபார்க்கவும்.

இப்போது, இரண்டு CPU கோர்களும் பயன்படுத்தப்படுவதை நீங்கள் காண முடியும், இது ஒட்டுமொத்த CPU பயன்பாட்டை கிட்டத்தட்ட 100%-க்குக் கொண்டு செல்லும்.

ஒற்றை-இழை செயல்முறைகளின் வரம்புகள்

நீங்கள் CPU கோர்களின் எண்ணிக்கையை அதிகரித்தாலும், ஒற்றை-இழை செயல்முறைகளான yes போன்றவற்றின் செயல்திறன் மேம்படாது என்பதைக் கவனத்தில் கொள்ள வேண்டும். உதாரணமாக, உங்களிடம் 32 கோர்களைக் கொண்ட சர்வர் இருந்தால், ஒரே ஒரு yes கட்டளையை இயக்குவது இன்னும் ஒரு கோரை மட்டுமே பயன்படுத்தும். ஏனென்றால், அதனுடைய பணிச்சுமையை பல கோர்களுக்கு இடையே பிரிக்க முடியாது.

இதற்கு மாறாக, மென்பொருள் உருவாக்கங்கள் (software builds) அல்லது தரவு பகுப்பாய்வு (data analysis) போன்ற பல இழைகளைப் பயன்படுத்தக்கூடிய பணிகள், அதிக கோர்கள் இருப்பதன் மூலம் பயனடையும்.

முடிவுரை

இந்த yes கட்டளை மற்றும் CPU பயன்பாடு பற்றிய இந்த ஆய்வு, Linux எவ்வாறு செயல்முறைகளைக் கையாள்கிறது என்பதைப் பற்றி எனக்கு நிறையக் கற்றுக் கொடுத்தது. CPU சுமையைத் திறம்பட நிர்வகிப்பதற்கு ஒற்றை-இழை மற்றும் பல-இழை செயல்முறைகளின் தன்மையைப் புரிந்துகொள்வது மிகவும் முக்கியமானது.

நன்மைகள்

  • CPU சுமையை உருவாக்குவதற்கான எளிய கட்டளை.
  • புரிந்துகொள்வதற்கும் செயல்படுத்துவதற்கும் எளிதானது.
  • CPU செயல்திறனைச் சோதிக்க பயனுள்ளது.

குறைபாடுகள்

  • பல CPU கோர்களைத் திறம்படப் பயன்படுத்துவதில்லை.
  • ஒற்றை-இழை செயல்திறனுடன் மட்டுமே வரம்பிற்குட்பட்டது.
  • மல்டிகோர் அமைப்புகளில் விரிவான சுமை சோதனைக்கு ஏற்றது அல்ல.

எச்சரிக்கை

இந்தக் கட்டுரை கல்வி நோக்கங்களுக்கானது. கட்டளைகளில் உள்ள ஒதுக்கிட மதிப்புகளை (placeholder values) உங்கள் உண்மையான தரவைக் கொண்டு மாற்றுவதை நினைவில் கொள்ளுங்கள். தகவல்களை நம்புவதற்கு முன் எப்போதும் அசல் மூலங்களுடன் சரிபார்க்கவும்.

அடிக்கடி கேட்கப்படும் கேள்விகள்

  • yes கட்டளை என்ன செய்கிறது? — yes கட்டளையானது ஒரு சரத்தை மீண்டும் மீண்டும் வெளியிடுகிறது, இது பொதுவாகச் சோதனைக்காகப் பயன்படுத்தப்படுகிறது.
  • எனது yes கட்டளை ஏன் CPU பயன்பாட்டை உச்சநிலைக்குக் கொண்டு செல்லவில்லை? — yes கட்டளையானது ஒற்றை-இழையைக் கொண்டது மற்றும் ஒரு நேரத்தில் ஒரு CPU கோரை மட்டுமே பயன்படுத்துகிறது.
  • எனது CPU கோர்களை நான் எவ்வாறு முழுமையாகப் பயன்படுத்துவது? — CPU கோர்களின் எண்ணிக்கைக்குச் சமமாக ஒரு கட்டளையின் பல நிகழ்வுகளை இயக்கவும்.
  • ஒற்றை-இழை செயல்முறை என்றால் என்ன? — ஒரு ஒற்றை-இழை செயல்முறை ஒரு நேரத்தில் ஒரு CPU கோரில் மட்டுமே இயங்க முடியும்.
  • கூடுதல் CPU கோர்களைச் சேர்ப்பதன் மூலம் நான் செயல்திறனை மேம்படுத்த முடியுமா? — ஒற்றை-இழை செயல்முறைகளுக்கு முடியாது; அவை கூடுதல் கோர்களால் பயனடையாது.
  • Linux-ல் CPU பயன்பாட்டை எவ்வாறு சரிபார்ப்பது? — நிகழ்நேரத்தில் CPU பயன்பாட்டைக் கண்காணிக்க இந்த top கட்டளையைப் பயன்படுத்தவும்.

குறிச்சொற்கள்

#linux #cpu #performance #loadtest #command #testing #system #process

Free field guide

Prompt-Injection Defense Checklist

The controls that actually reduce the blast radius when your app feeds untrusted text to an LLM. Enter your email — you'll get the PDF instantly, plus new posts on AI, security & Linux.