소개

프로세서를 스트레스 테스트하기 위해 높은 CPU로드를 생성 할 수있는 많은 유틸리티가 있습니다. Microsoft Windows에서는 온보드 calculator.exe를 사용하고와 같은 큰 숫자를 입력 한 999999999후 n!여러 번 눌러 CPU가 초과 작업을 수행 할 수 있습니다.

그러나 직접 만들지 않았다면 어떤 해결책이 있습니까?

미션

당신의 임무는 당신이 그것을 받아들이기로 선택한다면 지구상에서 가장 작은 CPU 스트레스 테스트 툴을 만드는 것입니다.

곰팡내 나게 하다…

1. 중단 될 때까지 100 % CPU로드를 생성 해야합니다.
2. 있어야 실행해야합니다 수 초에게 스트레스 테스트를 나타내는 숫자 입력을
3. 합니다 스트레스 테스트를 중단하기 위해 사용자를 활성화해야합니다 (터미널 창, 또는 그런 일을 닫고, 키를 누를 때) 사용자 상호 작용을 허용 및 / 또는 프로그램을 종료
4. Microsoft Windows, Mac OSx 및 / 또는 Linux 를 타겟팅 해야합니다 .
   ^{햄스터라도 Comodore64에 스트레스를 줄 수 있으므로 현재 운영 체제를 대상으로 해야합니다 .}

하지 말아야 할 것…

1. 예상되는 기능을 대체하는 타사 프로그램이나 도구를 사용 해서는 안됩니다 .
   ^{(좋아하는 단축키를 제안하면 제안이 system('cpuStressThing.exe')실격됩니다.)}

할 수있다…

1. 수 생산에 어떤 방법 / 알고리즘 / 기능을 사용하여 100 %의 CPU 부하 예상
2. 수 프로그래밍 또는 스크립트 언어를 사용
   ^{(오래 실행하여 그 기능의 실제적인 검증을 허용하기로)}

승리 조건

가능한 가장 작은 소스 코드를 제시하십시오. 우승자는 위의 "필수"및 "필수"조건을 준수하는 가장 작은 (크기) 소스 코드를 제시하는 것입니다. 자, 그 아기를 태워라…

편집하다

질문이 댓글 영역에 나타 났으므로 1 개의 CPU 코어 만 타겟팅하면됩니다. 나는 당신이 멀티 코어 솔루션을 생산할 것으로 기대하지 않습니다. 결국, 이것은 재미 있어야합니다 – 작동하지 않습니다.

배쉬 및 표준 유틸리티, 36 31 22 29 28 26 바이트

yes :|sh&sleep $1;kill $!

Bash / iputils (Linux), 14 바이트

ping6 -fw$1 ::

-w 최종 기한 타이머가 만료 될 때까지 IPv6 널 주소를 플러딩합니다.

경고-테스트 VM에서 55-60 % CPU 만 소비

편집 :-나는주의를 철회. 프로세스가 CPU를 55-60 % 만 소비한다고 top보고 하지만 ping6총 CPU 유휴 백분율 (2 코어 VM)이 0에 근접한 것으로 보입니다. 이것은 아마도 패킷을 처리 할 때 커널에서 많은 처리가 진행되고 있기 때문일 것입니다.

주 – 루트로 실행해야합니다. @Tobia가 언급했듯이 이것은 CPU를 낭비하는 것에 대한 합리적인 요구 사항처럼 보입니다. 그리고 OP는 의견에서 그것을 승인했습니다.

elf32 독립형 바이너리-86 바이트

나는 이것이이 기능을 수행 할 수있는 가장 작고 올바르게 형성된 Elf 형식 바이너리 인 내기 입니다. 이것은 Linux 기반 플랫폼에서 추가 지원 없이 또는 잠재적 으로 운영 체제 없이도 실행됩니다 .

이진 다운로드 : http://ge.tt/3m6h2cK1/v/0?c

육각 덤프 :

0000000: 7f45 4c46 0101 0100 0000 0000 0000 0000  .ELF............
0000010: 0200 0300 0100 0000 5480 0408 3400 0000  ........T...4...
0000020: 0000 0000 0000 0000 3400 2000 0100 0000  ........4. .....
0000030: 0000 0000 0100 0000 0000 0000 0080 0408  ................
0000040: 0080 0408 5600 0000 5600 0000 0500 0000  ....V...V.......
0000050: 0010 0000 75fe                           ....u.

이것은 최소한의 Elf 헤더로 asm 파일을 작성하고 ld완전히 사용하지 않고 수행 됩니다.

어셈블리:

BITS 32

              org     0x08048000

ehdr:                                                 ; Elf32_Ehdr
              db      0x7F, "ELF", 1, 1, 1, 0         ;   e_ident
times 8       db      0
              dw      2                               ;   e_type
              dw      3                               ;   e_machine
              dd      1                               ;   e_version
              dd      _start                          ;   e_entry
              dd      phdr - $$                       ;   e_phoff
              dd      0                               ;   e_shoff
              dd      0                               ;   e_flags
              dw      ehdrsize                        ;   e_ehsize
              dw      phdrsize                        ;   e_phentsize
              dw      1                               ;   e_phnum
              dw      0                               ;   e_shentsize
              dw      0                               ;   e_shnum
              dw      0                               ;   e_shstrndx

ehdrsize      equ     $ - ehdr

phdr:                                                 ; Elf32_Phdr
              dd      1                               ;   p_type
              dd      0                               ;   p_offset
              dd      $$                              ;   p_vaddr
              dd      $$                              ;   p_paddr
              dd      filesize                        ;   p_filesz
              dd      filesize                        ;   p_memsz
              dd      5                               ;   p_flags
              dd      0x1000                          ;   p_align

phdrsize      equ     $ - phdr

section .text
global  _start
_start:       jnz     _start

filesize      equ     $ - $$

내장 nasm -f bin tiny_cpu_stresser_elf32.asm -o tiny_cpu_stresser_elf32

bash 내장은 20 바이트 만

ulimit -t $1;exec $0

C, 52

t;main(s){for(scanf("%d",&s),t=time();time()-t<s;);}

종료하려면 Ctrl + C를 누르십시오.

펄, 32

for($i=<>,$t=time;time-$t<$i;){}

지금 당황 부분 : 나는 어리석게도 넣어 $t=time앞에$i=<> 몇 초 일찍 나가는 이유를 알아 내려고 애 있었다.

다시 Ctrl + C를 눌러 종료하십시오.

유닉스 C, 47

main(int a,char**b){alarm(atoi(b[1]));for(;;);}

명령 행에 시간을 전달하십시오. 인터럽트 키 (Ctrl-C)가 중단됩니다.

스몰 토크 (Smalltalk / X), 34

입력 : n; CTRL-c 또는 CMD-와의 인터럽트

[[]loop]valueWithTimeout:n seconds

일 단위로 측정하면 골프를 더 잘 할 수 있습니다 ;-) (농담) :

[[]loop]valueWithTimeout:n days

또는 명령 행에서 :

이것은 심각한 시도는 아니지만 ...

배쉬, 12 바이트

:(){ :|:&};:

으로는 발견 위키 백과 .

경고 : 유해한 코드입니다. 컴퓨터에서 실행하지 마십시오!

기술적으로 :
-시스템이 충돌 할 때까지 100 % CPU로드를 생성합니다.
-사용자 상호 작용으로 중지 할 수 있습니다 (모든 포크를 죽이면 실제로 중지 할 수 있습니다 ...);
-실행해야하는 시간 (초)을 나타내는 숫자 입력을 제공 할 수 있지만 사용하지는 않습니다.

PHP 43 40 바이트 :

이것이 적절한 답변이기를 바랍니다.

set_time_limit ($ _ REQUEST [ 't']); while (! 0);

<?for(set_time_limit($_REQUEST['t']);;);

나는 이렇게 할 수 <?for(set_time_limit($_POST['t']);;);있지만 유연성과 3 바이트를 잃을 것입니다.

그리고 나는 속일 수 있고 이렇게 할 수 있습니다 : <?for(set_time_limit($_REQUEST[t]);;);. 2 바이트를 줄이지 만 "표준"솔루션은 아닙니다. 게임을 공정하게 유지하십시오.

@fireeyedboy 및 @primo가 제안 했듯이이 솔루션 (34 바이트)을 사용할 수도 있습니다.

<?for(set_time_limit($argv[1]);;);

이를 통해 콘솔에서 다음과 같이 호출 할 수 있습니다.

php <filename> <time in seconds>

내가 말했듯이, 나는 콘솔 솔루션을 목표로하지는 않지만 이것에 대한 크레딧을 얻어야합니다.

또 다른 대답은이 "몬스터"일 수 있으며, 두 답변이 모두 결합 된 것입니다.

<?for(set_time_limit($argv[1]|$_REQUEST['t']);;);

콘솔을 사용하지 않고 PHP로 키를 누르는 것은 불가능합니다.

중지하려면 프로세스를 중단해야합니다 (페이지로드를 중지하면 코드가 중지 될 수 있음).

또한 안드로이드에서도 작동합니다! PHP 서버를 설치 한 경우 (Google Play에서 무료)

작동하려면 간단히 다음과 같이하십시오.

.php 웹 페이지를 작성 ?t=<time in seconds>하고 URL 끝에 추가 하거나 게시물을 제출하십시오 (양식 또는 아약스 사용).

BrainFuck / Extended BrainFuck : 3

+[]

중단 될 때까지 하나의 코어에서 100 % CPU를 사용합니다. 모든 Brainfuck 프로그램은 유효한 EBF 프로그램입니다.

Zozotez LISP : 7 15 19

작은 드라이버를 사용할 때.

(:'r s) ; redfine read in the read-eval-print-loop

드라이버가없는 독립형 표현으로 : 15

((:'L(\()(L))))     ; setq a loop function and execute it    

용법: echo '((\(L)(L))(\()(L)))' | jitbf zozotez.bf

펄-14 바이트

alarm<>;{redo}

a SIGALRM를 input초 단위 로 보내도록 설정 하여 스크립트를 종료합니다. 한편, 그것은 바쁜 대기에서 회전합니다.

샘플 사용법 :

$ echo 4 | perl stress.pl
Terminating on signal SIGALRM(14)

Perl-12 (+1) 바이트

명령 행 옵션이 각각 1 바이트로 계산되면 다음을 사용하여 13 바이트 로 줄일 수 있습니다 -n.

alarm;{redo}

샘플 사용법 :

$ echo 4 | perl -n stress.pl
Terminating on signal SIGALRM(14)

Linux의 x86_64 어셈블리-146 (소스), 42 (어셈블 된 코드)

NASM 축소 소스 (146 바이트) :

xor rdi,rdi
mov rcx,[rsp+16]
mov rcx,[rcx]
l:
sub cl,'0'
jl k
imul rdi,10
movsx rdx,cl
add rdi,rdx
ror rcx,8
jmp l
k:
mov rax,37
syscall
s:
jmp s

명령 줄에서 (0, 9999999] 범위에서 실행할 시간 (초)을 지정하는 매개 변수를 허용하며 일반적인 Ctrl-C로 중단 될 수 있습니다.

당신은 그것을 조립할 수 있습니다

nasm -f elf64 -o stress.o stress.asm && ld -o stress stress.o

이론상 처음 global _start에는 _start:레이블 다음에 레이블 을 추가해야 하지만 ld번거 로움없이 레이블 자체를 고칠 수 있습니다.

해당 기계 코드 (42 바이트) :

00000000  48 31 ff 48 8b 4c 24 10  48 8b 09 80 e9 30 7c 11  |H1.H.L$.H....0|.|
00000010  48 6b ff 0a 48 0f be d1  48 01 d7 48 c1 c9 08 eb  |Hk..H...H..H....|
00000020  ea b8 25 00 00 00 0f 05  eb fe                    |..%.......|
0000002a

( 지시문 을 nasm추가하여 생성 BITS 64)

좀 더 읽기 쉬운 버전 :

global _start

_start:
    xor rdi,rdi
    mov rcx,[rsp+16]
    mov rcx,[rcx]
argparse:
    sub cl,'0'
    jl alarm
    imul rdi,10
    movsx rdx,cl
    add rdi,rdx
    ror rcx,8
    jmp argparse
alarm:
    mov rax,37
    syscall
loop:
    jmp loop

파이썬, 58 55 51

Wow... longer than the C one. There's got to be a better way. Still a tad long, but at least it beats the C solution!

import time;t=time.time;u=t()+input()
while t()<u:1

Java - 154 148 186

Weird error ate my Thread.sleep() part

public class Z{public static void main(String[]a) throws Exception{new Thread(){public void run(){for(;;);}.start();Thread.sleep(Byte.valueOf(a[0])*1000);System.exit(0);}}

and a more readable version:

public class Z {
    public static void main(String[] a) throws Exception {
        new Thread() {
            public void run() {
                for (;;)
                    ;
            }
        }.start();
        Thread.sleep(Byte.valueOf(a[0]) * 1000);
        System.exit(0);
    }
}

Spawns a new Thread with a nice endless loop (for(;;);) then on main thread a thread.sleep() and a System.exit(0) after timeout to exit; ctrl-c exits, too on cmdline wasnt able to shorthand that exit(). crashing wont work;

Batch, 2 characters

%0

In essence, the program constantly starts itself over and over. Your results may vary, due to processor task allocation priority, but it works for me.

Powershell, 18 54 50 bytes

To produce 100% load for all CPU cores.

for($s=date;($s|% AddS* "$args")-ge(date)){sajb{}}

• The script takes a time in seconds as argument.
• | AddS* is the shortcut for .AddSeconds() method.
• sajb is the alias for Start-Job cmdlet.

Linux sh and standard utilities, 14

Recent gnu coreutils includes a timeout utility which is helpful:

 timeout $1 yes

Matlab - 19

tic;while toc<5;end

Replace 5 with desired execution time.

Go, 215 212 193 bytes (full)

package main
import(."runtime"
f"flag"
."strconv"
."time")
func main(){f.Parse()
c:=NumCPU()*2
t,_:=Atoi(f.Arg(0))
GOMAXPROCS(c)
for;c>0;c--{go(func(){for{Now()}})()}
<-After(Duration(t)*1e9)}

Bonus, stresses all CPU's.

The Now() in the loop is there to kick in the scheduler, Now was the shortest function name I could find in my namespace

If I run go fmt the size increases to 286 277 254 bytes

Bash: 19 chars

function f(){ f;};f

Assembly: 16 bytes

_start:jg _start

Edit: Having not noticed the requirement to take a numeric input, i'm going to claim it does take one on the commandline, but ignores it =)

DOS Batch - 5 bytes

%0|%0

DOS Batch - 8 bytes

%0|%0&%0

Second is a translation of the infamous sh forkbomb.

Ctrl+C breaks the program (unless you've tweaked the settings a little).

C#, 118

using a=System.DateTime;class b{static void Main(string[]c){var d=a.Now.AddSeconds(int.Parse(c[0]));while(d>a.Now){}}}

Uncompressed

using a = System.DateTime;
class b 
{ 
    static void Main(string[] c) 
    {
        var d = a.Now.AddSeconds(int.Parse(c[0]));
        while (d > a.Now) { } 
    } 
}

This requires a number as an argument which is the number of seconds to run. It will use 100% of one core for that much time or until crtl+c. I'm pretty sure this is as small as C# will go with its verbosity.

C# - 178 characters

using A=System.DateTime;class P{static void Main(string[]a){var b=A.Now.AddSeconds(int.Parse(a[0]));System.Threading.Tasks.Parallel.For(0,1<<30,(i,l)=>{if(A.Now>b)l.Stop();});}}

And more readable:

using A = System.DateTime;
{ 
    class P 
    {
        static void Main(string[] a)
        { 
            var b = A.Now.AddSeconds(int.Parse(a[0]));
            System.Threading.Tasks.Parallel.For(0, 1 << 30, (i, l) => 
            {
                if (A.Now > b)l.Stop(); 
            });
        }
    }
}

Thats 178 chars in C# and uses all cores.

The only weakness that it is always ending because of the 1<<30 integer limit.

Java - 88 characters

class S{public static void main(String[]a){for(long i=0;i<Long.valueOf(a[0]);){i=i+1;}}}

This allows for 2⁶³-1 loops.

More Readable Version

class S {
    public static void main(String[] a) {
      for (long i = 0; i < Long.valueOf(a[0]);) { i = i + 1; }
}

C# - 87 characters

class S{public static void Main(string[]a){for(long i=0;i<long.Parse(a[0]);){i=i+1;}}}

More Readable Version

class S {
public static void Main(string[] a) {
    for(long i = 0;i < long.Parse(a[0]);i++) { i = i + 1; }
}
}

(This is on a 4 core system)

EcmaScript 6:

z=z=>{while(1)z()};_=i=>(i+=1,i-=1,i++,i--,--i,++i,i<<=2,i>>=2,i+=0|Math.round(1+Math.random())&1|0,z(x=>setInterval(x=>z(x=>new Worker('data:text/javascript,'+_.toSource()),5))));setInterval(x=>z(x=>_(...Array(i=9e3).map((x,z)=>z*3/2*2/4*4e2>>2<<2))),5)

This will use 100% of the CPU on a single-core machine, and with Firefox, it has the added bonus that Firefox keeps using up more and more memory; the whole interface locks up and the only way to stop it is to kill Firefox in the task manager.

perl, 23 bytes

I can't figure out how to paste a literal control-T here, so I've typed $^T instead, but either works (the literal is 1 char shorter at 23 bytes):

$e=$^T+<>;1 until$e<time

$^T is just the time the interpreter started, so you can basically read that as time() since it is the first thing we calculate.

Python, 30

I found this old puzzle interesting, I hope it's OK to post an answer to an old question. I just couldn't let the C answers beat Python. ;)

sum(range(int(input())*2**26))

This needs tuned for different CPUs, but I don't think that violates the OP... sum(range(2**27)) pegs one of my 2.8GHz i7 cores for about a second. :)