मैं लिनक्स सर्वर पर उच्च सीपीयू लोड कैसे पैदा कर सकता हूं?

Question

मैं वर्तमान में एक Cacti स्थापना डिबगिंग की प्रक्रिया में हूँ और अपने CPU उपयोग ग्राफ़ को डीबग करने के लिए CPU लोड बनाना चाहता हूं।

मैंने बस चलाने की कोशिश की cat /dev/zero > /dev/null, जो शानदार काम करता है लेकिन केवल 1 कोर का उपयोग करता है:

क्या लोड के तहत परीक्षण / अधिकतम-आउट सिस्टम संसाधनों का बेहतर तरीका है?

संबंधित: मैं विंडोज पर उच्च सीपीयू लोड कैसे पैदा कर सकता हूं?

Comments

क्या catएक साथ कई उदाहरण चलाना संभव है ?

— नैट कोपेनहेवर

@NateKoppenhaver: हाँ, यह संभव है कि उन्हें screenसत्रों में लपेटते समय संभव हो । लेकिन अगर संभव हो तो मैं एक अधिक परिष्कृत समाधान पसंद करूंगा।

— डेर होकस्टापलर

हे, मैं हमेशा इस्तेमाल किया cat /dev/random > /dev/null। अनुमान /dev/zeroभी काम करता है। :-)

— oKtosiTe

@oKtosiTe बिल्ली / देव / यादृच्छिक में एन्ट्रापी को देव / यादृच्छिक / कम करने का दुष्प्रभाव है। कई बार आपको एन्ट्रापी के संरक्षण की आवश्यकता होती है, मेरे पास सीपीयू हॉग में जाने के लिए ऐसा नहीं होता।

— रिच होमोलका

@oKtosiTe रिच होमोलका ने जो कहा वह सही है, लेकिन यह सिर्फ इतना ही नहीं है कि यह एक बुरी बात है, यह भी बेकार है क्योंकि यह लगभग तुरंत ब्लॉक हो जाएगा और सीपीयू का सेवन बंद कर देगा।

— ल्यूक

Answer 1

कोशिश करें कि stress यह विंडोज के बराबर है consume.exe:

oliver$ ./stress --cpu 3
stress: info: [18472] dispatching hogs: 3 cpu, 0 io, 0 vm, 0 hdd

Comments

ubuntu पर, आप के साथ स्थापित कर सकते हैंsudo apt-get install stress

— बेन

डेबियन व्हीज़ी पर भी।

— enapupe

फेडोरा पर,sudo yum install stress

— क्रिस्टोफर मार्किटा

आर्क:sudo pacman -S stress

— das_j

brew install stressOS X पर

— क्रिश्चियन लॉन्ग

Answer 2

किसी भी अतिरिक्त पैकेज को स्थापित करने की आवश्यकता नहीं है, आपका अच्छा पुराना शेल इसे अकेले करने में सक्षम है।

यह एक-लाइनर अपने चार केंद्रों को लोड होगा ¹ 100% पर:

for i in 1 2 3 4; do while : ; do : ; done & done

यह कैसे काम करता है काफी सरल है, यह चार अंतहीन छोरों को शुरू करता है। उनमें से प्रत्येक शून्य निर्देश ( :) दोहरा रहा है । प्रत्येक लूप एक CPU कोर को 100% पर लोड करने में सक्षम है।

यदि आप उपयोग करते हैं bash, ksh93और अन्य गोले समर्थन पर्वतमाला, (अर्थात नहीं dashया अधिक पुराने ksh), तो आप इस गैर पोर्टेबल सिंटैक्स का उपयोग कर सकते हैं:

for i in {1..4}; do ...

4सीपीयू की संख्या से प्रतिस्थापित करें जिसे आप अलग से लोड करना चाहते हैं 4।

यह मानते हुए कि आपके पास पहले से चल रही कोई पृष्ठभूमि नौकरी नहीं थी, जब आपने इनमें से एक लूप लॉन्च किया था, तो आप उस कमांड के साथ लोड जेनरेशन को रोक सकते हैं:

for i in 1 2 3 4; do kill %$i; done

---

@ अंडरस्कोर_ड की टिप्पणी का उत्तर देते हुए, यहां एक वर्धित संस्करण है जो लोड को रोकने में बहुत सरल करता है और जो टाइमआउट (डिफ़ॉल्ट 60 सेकंड) को निर्दिष्ट करने की भी अनुमति देता है Control- ए - Cसभी भगोड़े छोरों को भी मार देगा। यह शेल फंक्शन कम से कम bashऔर के तहत काम करता है ksh।

# Usage: lc [number_of_cpus_to_load [number_of_seconds] ]
lc() {
  (
    pids=""
    cpus=${1:-1}
    seconds=${2:-60}
    echo loading $cpus CPUs for $seconds seconds
    trap 'for p in $pids; do kill $p; done' 0
    for ((i=0;i<cpus;i++)); do while : ; do : ; done & pids="$pids $!"; done
    sleep $seconds
  )
}

¹ _{ध्यान दें कि CPU प्रति कोर (हाइपर-थ्रेडिंग) एक से अधिक थ्रेड का समर्थन करने के साथ, OS सभी वर्चुअल CPU को लोड भेजेगा। उस स्थिति में, लोड व्यवहार कार्यान्वयन पर निर्भर है (प्रत्येक थ्रेड को 100% व्यस्त या नहीं के रूप में रिपोर्ट किया जा सकता है)।} ।

Comments

धन्यवाद, लेकिन &एक अलग थ्रेड या अलग कोर में चलने के लिए एक कमांड का कारण बनता है ? मैं उलझन में हूं।

— mmdemirbas

@mmdemirbas: एम्परसैंड कमांड को एक अलग प्रक्रिया के रूप में चलाने का कारण बनता है। अनुसूचक तब सभी उपलब्ध कोर को सभी सक्रिय प्रक्रियाओं को भेज रहा है।

— जुलैग्रे

एक अनुस्मारक के रूप में आप जारी करके इस परीक्षा को रोक सकते हैं killall bash- बस सुनिश्चित करें कि आपके पास उस समय चलने वाली कोई अन्य महत्वपूर्ण स्क्रिप्ट नहीं है।

— एक कोडर

@acoder पाश को समाप्त करने का एक तरीका बताने के लिए धन्यवाद। मैं फिर भी बचूंगा killall bash। लोड पीढ़ी को समाप्त करने के लिए एक सुरक्षित विधि जोड़ने के लिए संपादित उत्तर।

— जुलैग्रे

Lc शेल फ़ंक्शन के लिए +1

— अकिरा यामामोटो

Answer 3

मैंने एक साधारण अजगर की स्क्रिप्ट बनाई, जो ऐसा ही करती है। आप लोड करने के लिए इच्छित सीपीयू कोर की संख्या को नियंत्रित कर सकते हैं। इसके बारे में अच्छी बात यह है कि यह सीपीयू के अलावा किसी अन्य संसाधन का उपभोग नहीं करेगा। (मुझे लगता है कि जॉनसन के विचार से बहुत सारे I / O संसाधनों का उपभोग होता है, जो यहां अवांछित है।)

from multiprocessing import Pool

def f(x):
    # Put any cpu (only) consuming operation here. I have given 1 below -
    while True:
        x * x

# decide how many cpus you need to load with.
no_of_cpu_to_be_consumed = 3

p = Pool(processes=no_of_cpu_to_be_consumed)
p.map(f, range(no_of_cpu_to_be_consumed))

इस स्क्रिप्ट को टर्मिनल से चलाएं $ python temp1.py। जब आप कर रहे हों तो आपको स्क्रिप्ट को मारना होगा।

जब मैं अपने कोर के 3 लोड करता हूं तो यहां मेरा सीपीयू खपत आउटपुट है।

Comments

सीपीयू उपयोग को इस तरह से प्रदर्शित करने के लिए आपने किस कार्यक्रम का उपयोग किया? यह मुझे ऊपर की याद दिलाता है, लेकिन मुझे सीपीयू के चार्ट याद नहीं हैं।

— १:१२ बजे जफ्तागा

@jftuga शायद htop , शीर्ष सुंदर भाई।

— बोपरेह

हाँ, यह खोखला है। सर्वश्रेष्ठ वास्तविक समय, लिनक्स के लिए रंगीन इंटरैक्टिव प्रक्रिया दर्शक - htop.sourceforge.net

— पुष्पक

ध्यान नहीं दे रहा था और यह एक विंडोज बॉक्स पर चला गया। बहुत बुरी बातें ...

— डेरिक

Answer 4

एक वैकल्पिक तरीका होगा

openssl speed -multi $(grep -ci processor /proc/cpuinfo)

या (यदि nproc मौजूद है)

openssl speed -multi $(nproc --all)

ओपनएसएसएल आजकल डिस्ट्रोस पर लगभग हमेशा मौजूद रहता है, इसलिए अतिरिक्त पैकेज की आवश्यकता नहीं होती है।

Answer 5

दो शुरू करो

sha1sum /dev/zero &

आपके सिस्टम में हर कोर के लिए कमांड।

रोकने के लिए

killall sha1sum

या

kill sha1sum

Answer 6

मैं आमतौर पर सिपुर्न सुइट लेता हूं:

sudo apt-get install cpuburn
for i in {1..4}; do burnK7 & done

4 को कोर / एचटी-थ्रेड्स की संख्या से बदलें जो आपके पास हैं या तनाव करना चाहते हैं।

नोट: यह एक ही समय में जितना संभव हो उतना चिप क्षेत्र पर जोर देता है, यह अधिकतम बिजली अपव्यय उत्पन्न करने के लिए क्रमादेशित है। मुझे इस पोस्ट को दूसरी बार लिखना पड़ा, किसी तरह मेरी मशीन को यह पसंद नहीं आया :-(

तुम भी दृश्यों में cpuburn कर सकते हैं:

burnP6 & burnP6 & burnP6 & burnP6 & 
[1] 28520
[2] 28521
[3] 28522
[4] 28523

और जब आप उन्हें रोकना चाहते हैं:

killall burnP6

आप burnP6 &अपने सिस्टम पर CPU कोर की संख्या से मिलान करने के लिए गुणा भी कर सकते हैं ।

Answer 7

मैं तनाव-एनजी विकसित कर रहा हूं, एक अद्यतन तनाव उपकरण जो लिनक्स सिस्टम के पहलुओं की एक विस्तृत श्रृंखला को तनाव दे सकता है। अधिक जानकारी के लिए, http://kernel.ubuntu.com/~cking/stress-ng/ देखें

उपयोग तनाव के समान है

$ stress-ng --cpu 4 --vm 2 --fork 8 --switch 4 --timeout 1m
stress-ng: info:  [32254] dispatching hogs: 4 cpu, 8 fork, 4 switch, 2 vm
stress-ng: info:  [32254] cache allocate: default cache size: 8192K

के साथ स्थापित करें

sudo apt-get install stress-ng

Comments

कृपया पढ़ें कि मैं कुछ युक्तियों के लिए सॉफ्टवेयर की सिफारिश कैसे करूं कि आपको सॉफ्टवेयर की सिफारिश करने के बारे में कैसे जाना चाहिए। बहुत कम से कम आपको कम से कम / कम से कम एक लिंक प्रदान करना चाहिए, उदाहरण के लिए सॉफ़्टवेयर के बारे में कुछ अतिरिक्त जानकारी और प्रश्न में समस्या को हल करने के लिए इसका उपयोग कैसे किया जा सकता है।

— DavidPostill

Answer 8

आप जितनी बार चाहें उतनी बार इस कमांड को चला सकते हैं, और यह हर बार एक अलग कोर लेगा:

$ CORES=1
$ for i in `seq 1 $CORES`; do cat /dev/zero > /dev/null &
> done
[1] 8388

Comments

क्या यह प्रक्रिया को थोडा मुश्किल नहीं होगा?

— oKtosiTe

killall catकरना चाहिए।

— क्रिश्चियन मान

इस पर निर्भर करता है कि आपके पास अन्य catप्रक्रियाएं चल रही हैं (मैं आमतौर पर करता हूं)।

— oKtosiTe

Answer 9

https://github.com/GaetanoCarlucci/CPULoadGenerator

बहुत सरल और वैज्ञानिक समाधान।

यहां आप डायनामिक्स का उदाहरण देख सकते हैं जिसमें CPU कोर 0 पर 50% लोड उत्पन्न होता है:

आप एक ही समय में अन्य कोर पर प्रक्रिया चला सकते हैं।

Answer 10

मैंने + jlliagre और + ecabuk दोनों को मिलाया।

#!/bin/bash
lc() {
    nowMs=$(date +%s)
    (
        pids=""
        cpus=${1:-1}
        seconds=${2:-60}
        echo "[$(date)] loading $cpus CPUs for $seconds seconds"
        echo "[$(date)] Expected completion: [$(date --date=@$(expr $nowMs + $seconds))]"
        trap 'for p in $pids; do kill $p; done' 0
        for ((i=0;i<cpus;i++)); do
            sha1sum /dev/zero &
            pids="$pids $!";
        done
        sleep $seconds
    )
    echo "[$(date)] Done"
}

lc $@

Answer 11

आप उपयोग कर सकते हैं:

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

dd if=/dev/zero of=/dev/nullअपने सीपीयू कोर के लिए दोहराएं ।

परीक्षण को रोकने के लिए किसी भी कुंजी को मारो।

Answer 12

pxzका समानांतर कार्यान्वयन है xz।

pxz -9e /dev/zero --stdout >/dev/null चाल करना चाहिए, क्योंकि यह काफी सीपीयू गहन है।

यदि /dev/zeroआप तेजी से पर्याप्त नहीं हैं (आप नोटिस करते हैं कि pxzमुझे I / O थ्रॉटल मिलता है) तो आप कर सकते हैं pxz -9e /dev/zero --stdout | pxz -9e --stdout >/dev/null

नए संस्करणों के xzलिए --threadsविकल्प है जो एक विकल्प है pxz।

Answer 13

यहाँ मैं उपयोग कर रहा हूँ और कुछ भी अतिरिक्त स्थापित करने की आवश्यकता नहीं है।

4 प्रक्रियाओं के साथ शुरू करने के लिए उदाहरण के लिए,

nproc | xargs seq | xargs -n1 -P4 md5sum /dev/zero

आप ऊपर दिए गए विकल्प "-P" द्वारा प्रक्रियाओं की संख्या बदल सकते हैं।

Answer 14

एक साधारण कमांड लाइन इसे भी करती है:

x="x" ; while : ; do x=$x$x ; echo -n "." ; done

Comments

यह सरल होगा:while : ; do : ; done

— jlliagre

@jlliagre आपका लोडाव 1 से ऊपर नहीं जाएगा

— ott--

आपका लूप मुख्य रूप से सीपीयू को लोड नहीं कर रहा है, बल्कि मेमोरी को भरता है। यह अंततः मेमोरी एरर के साथ क्रैश हो जाएगा।

— जॉलीग्रे

@jlliagre माइन मेमोरी को भरता है और स्वैप (यदि वर्तमान में) करता है, तो इस प्रकार 3 का भार पैदा होता है, इससे पहले कि वह मारा जाता है क्योंकि यह मेमोरी से बाहर निकलता है।

— ott--

यही समस्या है। आप उस प्रश्न का उत्तर नहीं दे रहे हैं जो सर्वर पर एक उच्च सीपीयू लोड का उत्पादन करने का तरीका है। आपकी स्क्रिप्ट जल्दी से एक सिस्टम को गैर-जिम्मेदार बना रही है और फिर क्रैश हो जाती है। 3. का for i in 1 2 3; do while : ; do : ; done & ; done

— लोडवाग

Answer 15

मैं इसे @ jlliagre की टिप्पणी में जोड़ना चाहता था, लेकिन मेरे पास पर्याप्त प्रतिष्ठा नहीं है। यदि आप कई सर्वरों पर इस कोड का उपयोग करने जा रहे हैं और सीपीयू की संख्या अलग-अलग होगी, तो आप निम्न कमांड का उपयोग कर सकते हैं:

for ((i=1; i<=`nproc --all`; i++)); do while : ; do : ; done & done

यह आपके सर्वर पर सभी कोर का उपयोग करेगा चाहे आप कितने भी हों। कमांड nprocकोरुटिल का हिस्सा है इसलिए अधिकांश लिनक्स इंस्टॉलेशन पर होना चाहिए।