मैं लिनक्स मशीन पर लगभग 100% लोड बनाना चाहता हूं। यह क्वाड कोर सिस्टम है और मैं चाहता हूं कि सभी कोर फुल स्पीड में जाएं। आदर्श रूप से, सीपीयू लोड एक निर्दिष्ट समय तक चलेगा और फिर बंद हो जाएगा। मैं उम्मीद कर रहा हूँ कि bash में कुछ ट्रिक है। मैं अनंत लूप के कुछ प्रकार सोच रहा हूँ।
जवाबों:
आप भी कर सकते हैं
dd if=/dev/zero of=/dev/nullअधिक कोर पर लोड डालने के लिए उन लोगों को चलाने के लिए, इसे कांटा करने की कोशिश करें:
fulload() { dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null | dd if=/dev/zero of=/dev/null & }; fulload; read; killall ddघुंघराले ब्रैकेट में कमांड को दोहराएं जितनी बार आप जितने धागे का उत्पादन करना चाहते हैं (4 धागे)। सरल प्रवेश हिट इसे रोक देगा (बस यह सुनिश्चित करें कि इस उपयोगकर्ता पर कोई अन्य डीडी नहीं चल रहा है या आप इसे भी मारते हैं)।
/dev/zeroऔर लिखना /dev/nullबहुत अच्छा लोड जनरेटर नहीं है - आपको महत्वपूर्ण भार उत्पन्न करने के लिए उनमें से बहुत कुछ चलाना होगा। कुछ करने के लिए बेहतर है dd if=/dev/urandom | bzip2 -9 >> /dev/null। /dev/urandomआउटपुट उत्पन्न करने के लिए काफी अधिक प्रयास की आवश्यकता होती है, और bzip2इसे संपीड़ित करने के प्रयास में बहुत अधिक खर्च होगा, इसलिए समग्र सीपीयू का उपयोग "शून्य के साथ एक ब्लॉक को भरने और फिर इसे दूर फेंकने" की तुलना में बहुत अधिक है।
jobs -p | xargs killआपके द्वारा बनाई गई प्रक्रियाओं को केवल मारने के लिए उपयोग करें ।
मैं इस तरह की चीज के लिए तनाव का उपयोग करता हूं , आप इसे बता सकते हैं कि कितने कोर अधिकतम करने के लिए .. यह स्मृति और डिस्क पर भी जोर देने की अनुमति देता है।
उदाहरण के लिए 60 सेकंड के लिए 2 कोर तनाव
stress --cpu 2 --timeout 60
sudo yum install stress
EPELCentOSwget http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm
sudo apt-get install stressपूर्णता के लिए डेबियन आधारित सिस्टम। Intel i7 NUC किट पर कूलिंग मॉड का परीक्षण करने के लिए इसका उपयोग किया ।
मुझे लगता है कि यह अधिक सरल है। टर्मिनल खोलें और निम्न टाइप करें और Enter दबाएँ।
yes > /dev/null &आधुनिक सीपीयू का पूरी तरह से उपयोग करने के लिए, एक पंक्ति पर्याप्त नहीं है, आपको सभी सीपीयू शक्ति को समाप्त करने के लिए कमांड को दोहराने की आवश्यकता हो सकती है।
इस सब को समाप्त करने के लिए, सीधे शब्दों में कहें
killall yesयह विचार मूल रूप से यहां पाया गया था , हालांकि यह मैक उपयोगकर्ताओं के लिए था, लेकिन इसके साथ ही * निक्स के लिए भी काम करना चाहिए।
yesकमांड 25% का कुल भार मिलेगा (यह मानते हुए कि सिस्टम अन्यथा निष्क्रिय था)।
हालाँकि मुझे पार्टी के लिए देर हो गई है, यह पोस्ट Google खोज "linux में जनरेट लोड" के शीर्ष परिणामों में से है।
समाधान के रूप में चिह्नित परिणाम का उपयोग सिस्टम लोड उत्पन्न करने के लिए किया जा सकता है, मैं उपयोग करना पसंद कर रहा हूं sha1sum /dev/zero एक सीपीयू-कोर पर लोड लगाने के करना ।
यह विचार एक अनंत डेटास्ट्रीम (जैसे। / देव / शून्य, / देव / यूरेनियम, ...) से एक हैश राशि की गणना करने के लिए है। यह प्रक्रिया प्रक्रिया समाप्त होने तक एक सीपीयू-कोर को अधिकतम करने की कोशिश करेगी। अधिक कोर के लिए लोड उत्पन्न करने के लिए, कई कमांड को एक साथ पाइप किया जा सकता है।
जैसे। एक 2 कोर लोड उत्पन्न करें:
sha1sum /dev/zero | sha1sum /dev/zero
एक कोर (बाहरी प्रक्रिया को लागू नहीं करता है):
while true; do true; doneदो कोर:
while true; do /bin/true; doneउत्तरार्द्ध केवल मेरा दोनों बनाता है ~ 50% हालांकि ...
यह एक दोनों 100% करने के लिए जाना होगा:
while true; do echo; donerenice 19 -p $$:। यह अभी भी सीपीयू को अधिकतम करेगा, लेकिन अन्य प्रक्रियाओं पर लागू नहीं होगा।
5 सेकंड के लिए 3 कोर लोड करने के लिए:
seq 3 | xargs -P0 -n1 timeout 5 yes > /dev/nullइसके परिणामस्वरूप कई लिखने () सिस्टम कॉल से उच्च कर्नेल (sys) लोड होता है।
यदि आप ज्यादातर यूजरलैंड सीपीयू लोड पसंद करते हैं:
seq 3 | xargs -P0 -n1 timeout 5 md5sum /dev/zeroयदि आप चाहते हैं कि लोड तब तक जारी रहे जब तक आप Ctrl-C नहीं दबाते:
seq 3 | xargs -P0 -n1 md5sum /dev/zeroयहाँ एक प्रोग्राम है जिसे आप यहाँ डाउनलोड कर सकते हैं
अपने लिनक्स सिस्टम पर आसानी से स्थापित करें
./configure
make
make installऔर इसे एक साधारण कमांड लाइन में लॉन्च करें
stress -c 40अपने सभी सीपीयू (हालांकि आपके पास) को 40 थ्रेड के साथ sqrtतनावपूर्ण तरीके से उत्पन्न संख्याओं पर एक जटिल संगणना चलाने के लिए।
आप प्रोग्राम के टाइमआउट को भी परिभाषित कर सकते हैं
stress -c 40 -timeout 10sddकमांड के साथ प्रस्तावित समाधान के विपरीत , जो अनिवार्य रूप से संबंधित है IOऔर इसलिए डेटा के साथ काम करने के कारण वास्तव में आपके सिस्टम को अधिभार नहीं देता है।
तनाव कार्यक्रम वास्तव में सिस्टम को ओवरलोड करता है क्योंकि गणना के साथ काम करना।
stressकमांड के लिए पहले से ही एक उत्तर ऊपर है । जैसा कि उत्तर कहता है, आप इसे केवल yum / apt / etc के माध्यम से स्थापित कर सकते हैं।
:(){ :|:& };:यह कांटा बम सीपीयू के लिए कहर पैदा करेगा और संभवतः आपके कंप्यूटर को दुर्घटनाग्रस्त कर देगा।
एक अनंत लूप वह विचार है जो मेरे पास भी था। एक अजीब लग रही है:
while :; do :; done( :जैसा है, वैसा ही trueकरता है और शून्य से बाहर निकलता है)
आप कॉल कर सकते हैं कि एक सबशेल में और पृष्ठभूमि में चला सकते हैं। उस $num_coresसमय करना पर्याप्त होना चाहिए। वांछित समय आप उन सभी को मार सकता है सो के बाद, आप के साथ PIDs मिल jobs -p(संकेत: xargs)
मैं इस चीज को 2 लिपियों में विभाजित करूंगा:
अनंत_लूप.बश:
#!/bin/bash
while [ 1 ] ; do
# Force some computation even if it is useless to actually work the CPU
echo $((13**99)) 1>/dev/null 2>&1
donecpu_spike.bash:
#!/bin/bash
# Either use environment variables for NUM_CPU and DURATION, or define them here
for i in `seq ${NUM_CPU}` : do
# Put an infinite loop on each CPU
infinite_loop.bash &
done
# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}
killall infinite_loop.bash#!/bin/bash
duration=120 # seconds
instances=4 # cpus
endtime=$(($(date +%s) + $duration))
for ((i=0; i<instances; i++))
do
while (($(date +%s) < $endtime)); do :; done &
doneमैंने bc( बाइनरी कैलकुलेटर ) का उपयोग किया है , उन्हें पीआई के लिए बहुत अधिक दशमलव के साथ पूछ रहा हूं।
$ for ((i=0;i<$NUMCPU;i++));do
echo 'scale=100000;pi=4*a(1);0' | bc -l &
done ;\
sleep 4; \
killall bcNUMCPU (लिनक्स के तहत) के साथ:
$ NUMCPU=$(grep $'^processor\t*:' /proc/cpuinfo |wc -l)यह तरीका मजबूत है, लेकिन सिस्टम फ्रेंडली लगता है , क्योंकि मैंने इसके इस्तेमाल से सिस्टम को कभी क्रैश नहीं किया है।
मैं इंटरनेट के माध्यम से ऐसा कुछ खोजने के लिए चला गया और यह बहुत आसान सीपीयू हथौड़ा स्क्रिप्ट मिली।
#!/bin/sh
# unixfoo.blogspot.com
if [ $1 ]; then
NUM_PROC=$1
else
NUM_PROC=10
fi
for i in `seq 0 $((NUM_PROC-1))`; do
awk 'BEGIN {for(i=0;i<10000;i++)for(j=0;j<10000;j++);}' &
doneNUM_PROC=${1:-10}:।
यहां बताए गए उदाहरणों का उपयोग करते हुए, लेकिन आईआरसी की मदद से, मैंने अपना स्वयं का सीपीयू तनाव परीक्षण स्क्रिप्ट विकसित किया। यह प्रति थ्रेड और अंतहीन लूप तकनीक का उपयोग करता है। आप थ्रेड्स की संख्या और इंटरेक्टिव रूप से समय की मात्रा भी निर्दिष्ट कर सकते हैं।
#!/bin/bash
# Simple CPU stress test script
# Read the user's input
echo -n "Number of CPU threads to test: "
read cpu_threads
echo -n "Duration of the test (in seconds): "
read cpu_time
# Run an endless loop on each thread to generate 100% CPU
echo -e "\E[32mStressing ${cpu_threads} threads for ${cpu_time} seconds...\E[37m"
for i in $(seq ${cpu_threads}); do
let thread=${i}-1
(taskset -cp ${thread} $BASHPID; while true; do true; done) &
done
# Once the time runs out, kill all of the loops
sleep ${cpu_time}
echo -e "\E[32mStressing complete.\E[37m"
kill 0यहां विचारों का उपयोग करते हुए, बनाया गया कोड जो एक निर्धारित अवधि के बाद स्वचालित रूप से बाहर निकल जाता है, प्रक्रियाओं को मारना नहीं पड़ता है -
#!/bin/bash
echo "Usage : ./killproc_ds.sh 6 60 (6 threads for 60 secs)"
# Define variables
NUM_PROCS=${1:-6} #How much scaling you want to do
duration=${2:-20} # seconds
function infinite_loop {
endtime=$(($(date +%s) + $duration))
while (($(date +%s) < $endtime)); do
#echo $(date +%s)
echo $((13**99)) 1>/dev/null 2>&1
$(dd if=/dev/urandom count=10000 status=none| bzip2 -9 >> /dev/null) 2>&1 >&/dev/null
done
echo "Done Stressing the system - for thread $1"
}
echo Running for duration $duration secs, spawning $NUM_PROCS threads in background
for i in `seq ${NUM_PROCS}` ;
do
# Put an infinite loop
infinite_loop $i &
doneडिंबा के उत्तर को बढ़ाने के लिए और कुछ अधिक उपलब्ध करने योग्य (क्योंकि मुझे कुछ इसी तरह की आवश्यकता थी)। मैंने dd लोड-अप अवधारणा का उपयोग करते हुए निम्नलिखित लिखा है: D
यह वर्तमान कोर की जांच करेगा, और कई dd थ्रेड्स बनाएगा। एंटर के साथ स्टार्ट और एंड कोर लोड
#!/bin/bash
load_dd() {
dd if=/dev/zero of=/dev/null
}
fulload() {
unset LOAD_ME_UP_SCOTTY
export cores="$(grep proc /proc/cpuinfo -c)"
for i in $( seq 1 $( expr $cores - 1 ) )
do
export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd | ')"
done
export LOAD_ME_UP_SCOTTY="${LOAD_ME_UP_SCOTTY}$(echo 'load_dd &')"
eval ${LOAD_ME_UP_SCOTTY}
}
echo press return to begin and stop fullload of cores
read
fulload
read
killall -9 ddमैंने कुछ उत्तरों को संयोजित किया और सभी उपलब्ध cpus में तनाव को मापने का एक तरीका जोड़ा:
#!/bin/bash
function infinite_loop {
while [ 1 ] ; do
# Force some computation even if it is useless to actually work the CPU
echo $((13**99)) 1>/dev/null 2>&1
done
}
# Either use environment variables for DURATION, or define them here
NUM_CPU=$(grep -c ^processor /proc/cpuinfo 2>/dev/null || sysctl -n hw.ncpu)
PIDS=()
for i in `seq ${NUM_CPU}` ;
do
# Put an infinite loop on each CPU
infinite_loop &
PIDS+=("$!")
done
# Wait DURATION seconds then stop the loops and quit
sleep ${DURATION}
# Parent kills its children
for pid in "${PIDS[@]}"
do
kill $pid
doneडिंबा dd if=/dev/zero of=/dev/nullनिश्चित रूप से सही है, लेकिन यह भी उल्लेखनीय है कि 100% उपयोग के लिए सीपीयू को अधिकतम करने की पुष्टि की जा रही है। आप इसके साथ कर सकते हैं
ps -axro pcpu | awk '{sum+=$1} END {print sum}'यह प्रत्येक प्रक्रिया द्वारा CPU उपयोग के 1-मिनट के औसत आउटपुट के लिए पूछता है, फिर उन्हें awk के साथ जोड़ देता है। हालांकि यह 1 मिनट का औसत है, पीएस यह जानने के लिए पर्याप्त स्मार्ट है कि क्या कोई प्रक्रिया केवल कुछ सेकंड के आसपास हुई है और समय-विंडो को तदनुसार समायोजित करता है। इस प्रकार आप परिणाम देखने के लिए तुरंत इस कमांड का उपयोग कर सकते हैं।
सीपीयू 100% लोड या उपभोग बढ़ाने के लिए
sha1sum /dev/zero &फिर आप कमांड टाइप करके CPU उपयोग देख सकते हैं
topलोड जारी करने के लिए
killall sha1sumबस इस बुरे लड़के को एसएसएच या किसी भी सर्वर के कंसोल में पेस्ट करें। आप मैन्युअल रूप से प्रक्रियाओं को मार सकते हैं, लेकिन मैं बस सर्वर को बंद कर रहा हूं जब मैं कर रहा हूं, तेज।
संपादित करें: मैंने इस स्क्रिप्ट को अब एक टाइमर सुविधा के रूप में अपडेट किया है ताकि प्रक्रियाओं को मारने की आवश्यकता न हो।
read -p "Please enter the number of minutes for test >" MINTEST && [[ $MINTEST == ?(-)+([0-9]) ]]; NCPU="$(grep -c ^processor /proc/cpuinfo)"; ((endtime=$(date +%s) + ($MINTEST*60))); NCPU=$((NCPU-1)); for ((i=1; i<=$NCPU; i++)); do while (($(date +%s) < $endtime)); do : ; done & done