Introducción

Hay muchas utilidades por ahí capaces de crear una alta carga de CPU para probar sus procesadores. En Microsoft Windows, incluso puede usar el dispositivo integrado calculator.exe, ingresar un número grande como 999999999y presionar n!varias veces para hacer que su CPU (s) trabaje horas extras.

Pero, ¿qué hay en una solución si no la creaste tú mismo?

La misión

Su misión, si elige aceptarla, es crear la herramienta de prueba de esfuerzo de CPU más pequeña del planeta.

Debe…

1. debe producir una carga de CPU del 100% hasta que se cancele
2. debe tomar una entrada numérica, que representa el número de segundos que debe ejecutarse la prueba de esfuerzo
3. debe permitir la interacción del usuario (presionar una tecla, cerrar la ventana del terminal o algo así) que debería permitir al usuario abortar la prueba de esfuerzo y / o salir del programa
4. debe apuntar a Microsoft Windows, Mac OSx y / o Linux.
   ^{(Incluso un hámster podría estresar a un Comodore64 ... por lo tanto, debe apuntar a un sistema operativo actual).}

No debe…

1. no debe usar programas o herramientas de terceros que reemplacen la funcionalidad esperada.
   ^{(Proponer accesos directos como system('cpuStressThing.exe')descalifica su propuesta).}

Mayo…

1. puede usar cualquier enfoque / algoritmo / funcionalidad para producir una carga de CPU del 100% esperada
2. puede usar cualquier lenguaje de programación o scripting
   ^{(siempre que permita una verificación práctica de su funcionalidad ejecutándolo)}

Condición ganadora

Presente el código fuente más pequeño posible. El ganador es el que presenta el código fuente más mínimo (en tamaño) que cumple con las condiciones "obligatorias" y "obligatorias" anteriores. Ahora, haz que el bebé se queme ...

EDITAR

Dado que la pregunta surgió en el área de comentarios ... solo necesita apuntar a 1 núcleo de CPU. Definitivamente no espero que produzcas una solución multi-core. Después de todo, esto debería ser divertido, no trabajo.

Bash y utilidades estándar, 36 31 22 29 28 26 bytes

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

Bash / iputils (Linux), 14 bytes

ping6 -fw$1 ::

La inundación hace ping a la dirección nula IPv6, hasta que caduque el temporizador de fecha límite -w

advertencia: solo consume 55-60% de CPU en mi máquina virtual de prueba

Editar: - Retraigo mi advertencia. Si bien topinforma que el ping6proceso solo consume 55-60% de CPU, veo que el porcentaje de inactividad total de la CPU (VM de 2 núcleos) se aproxima a cero. Presumiblemente, esto se debe a que gran parte del procesamiento se está llevando a cabo en el núcleo mientras maneja los paquetes.

Nota: debe ejecutarse como root. Como comenta @Tobia, esto parece un requisito razonable para algo que acaparará la CPU. Y el OP lo aprobó en los comentarios.

Binario independiente Elf32 - 86 bytes

Apuesto a que este es el binario de formato Elf más pequeño y correctamente formado que se puede hacer para realizar esta función. Esto se ejecutará sin ningún soporte adicional en ninguna plataforma basada en Linux, o potencialmente incluso sin un sistema operativo .

Descarga binaria: http://ge.tt/3m6h2cK1/v/0?c

Volcado hexadecimal:

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.

Esto se hace construyendo un archivo asm con un encabezado Elf mínimo propio, y omitiendo el uso de ld.

Montaje:

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     $ - $$

Construido con nasm -f bin tiny_cpu_stresser_elf32.asm -o tiny_cpu_stresser_elf32

bash incorpora solo 20 bytes

ulimit -t $1;exec $0

C, 52

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

Presione Ctrl + C para salir.

Perl, 32

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

Ahora la parte vergonzosa: tontamente me puse $t=timedelante $i=<>y estaba tratando furiosamente de descubrir por qué sale unos segundos antes.

De nuevo, Ctrl + C para salir.

Unix C, 47

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

Pase el tiempo en la línea de comando. La tecla de interrupción (Ctrl-C) aborta.

Smalltalk (Smalltalk / X), 34

entrada: n; interrumpir con CTRL-c o CMD-.

[[]loop]valueWithTimeout:n seconds

puede jugar mejor al golf, si se mide en días ;-) (es broma):

[[]loop]valueWithTimeout:n days

o desde una línea de comando:

Este no es un intento serio, pero ...

Bash, 12 bytes

:(){ :|:&};:

Como se encuentra en Wikipedia .

ADVERTENCIA: código dañino, ¡no lo ejecute en su computadora!

Técnicamente:
- Produce una carga de CPU del 100% hasta que el sistema falla;
- Permite que la interacción del usuario lo detenga (si logra matar todos los tenedores, puede detenerlo ...);
- Puede darle una entrada numérica que represente la cantidad de segundos que debe ejecutarse, pero no la usará.

PHP 43 40 bytes:

Espero que esta sea una respuesta aceptable:

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

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

Podría hacer esto: <?for(set_time_limit($_POST['t']);;);pero perdería flexibilidad y 3 bytes.

Y podría hacer trampa y hacer esto: <?for(set_time_limit($_REQUEST[t]);;); . Reduce 2 bytes, pero no es una solución "estándar". Mantengamos el juego justo.

Como sugirieron @fireeyedboy y @primo, también puede usar esta solución (34 bytes):

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

Esto permite su uso desde la consola, llamándolo así:

php <filename> <time in seconds>

Como dije, no estoy apuntando a la solución de consola, pero tienen que obtener el crédito por esta.

Otra respuesta podría ser este "monstruo", que es solo ambas respuestas combinadas:

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

Es imposible obtener pulsaciones de teclas en PHP, sin estar en la consola, ¡a lo que no estoy apuntando!

Para detenerlo, DEBE abortar el proceso (detener la carga de la página puede detener el código).

Como ventaja, ¡también funciona en Android! Si instala un servidor php (gratis en Google Play).

Para que funcione, simplemente haga lo siguiente:

Crea una página web .php y la agrega ?t=<time in seconds>al final de la url o envía una publicación (usando un formulario o incluso ajax).

BrainFuck / BrainFuck extendido : 3

+[]

Utilizará 100% de CPU en un núcleo hasta que se cancele. Todos los programas Brainfuck son programas EBF válidos.

Zozotez LISP : 7 15 19

Cuando se usa el pequeño controlador.

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

Como una expresión independiente sin conductor: 15

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

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

Perl - 14 bytes

alarm<>;{redo}

Establece SIGALRMque se envíeinput segundos, que finaliza el script. Mientras tanto, gira en una espera ocupada.

Uso de la muestra:

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

Perl - 12 (+1) bytes

Si las opciones de la línea de comandos se cuentan como un byte cada una, esto podría reducirse a 13 bytes usando un -n:

alarm;{redo}

Uso de la muestra:

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

Ensamblado x86_64 en Linux - 146 (fuente), 42 (código ensamblado)

La fuente minimizada NASM (146 bytes):

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

Acepta un parámetro en la línea de comando que especifica el número de segundos que se ejecutarán en el rango (0, 9999999]; se puede interrumpir con el Ctrl-C habitual.

Puedes armarlo con

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

En teoría, sería necesario agregar un global _startseguido de una _start:etiqueta al principio, pero se las ldarregla por sí solo con poco alboroto.

El código de máquina correspondiente (42 bytes):

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

(generado al nasmagregar la BITS 64directiva)

Una versión algo más legible:

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

Pitón, 58 55 51

Wow ... más largo que el de C. Tiene que haber una mejor manera. Todavía es un poco largo, ¡pero al menos supera la solución C!

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

Java - 154 148 186

Extraño error se comió mi Thread.sleep()parte

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);}}

y una versión más legible:

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);
    }
}

Genera un new Threadcon un bonito bucle sin fin ( for(;;);), entonces en la rosca de un principal thread.sleep()y un System.exit(0)después de tiempo de espera a la salida; ctrl-c sale, también en cmdline no fue capaz de abreviar eso exit(). estrellarse no funcionará;

Lote, 2 personajes

%0

En esencia, el programa se inicia constantemente una y otra vez. Sus resultados pueden variar, debido a la prioridad de asignación de tareas del procesador, pero funciona para mí.

Powershell, 18 54 50 bytes

Para producir una carga del 100% para todos los núcleos de CPU.

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

• El guión lleva un tiempo en segundos como argumento.
• | AddS*es el atajo para el .AddSeconds()método.
• sajbes el alias para Start-Jobcmdlet.

Linux sh y utilidades estándar, 14

Los recientes gutilu coreutils incluyen una timeoututilidad que es útil:

 timeout $1 yes

Matlab - 19

tic;while toc<5;end

Reemplace 5con el tiempo de ejecución deseado.

Go, 215 212 193 bytes (completo)

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)}

Bonificación, enfatiza todas las CPU.

El Now()en el bucle está ahí para patear el planificador,Now fue el nombre de función más corto que pude encontrar en mi espacio de nombres

Si ejecuto go fmtel tamaño aumenta a 286 277 254 bytes

Golpe: 19 caracteres

function f(){ f;};f

Asamblea: 16 bytes

_start:jg _start

Editar: al no haber notado el requisito de tomar una entrada numérica, voy a afirmar que toma una en la línea de comando, pero la ignora =)

Lote DOS - 5 bytes

%0|%0

Lote DOS - 8 bytes

%0|%0&%0

El segundo es una traducción de la infame sh forkbomb.

Ctrl + C interrumpe el programa (a menos que haya modificado un poco la configuración).

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){}}}

Sin comprimir

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

Esto requiere un número como argumento, que es el número de segundos para ejecutarse. Utilizará el 100% de un núcleo durante ese tiempo o hasta crtl + c. Estoy bastante seguro de que esto es tan pequeño como C # irá con su verbosidad.

C # - 178 caracteres

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();});}}

Y más legible:

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(); 
            });
        }
    }
}

Eso es 178 caracteres en C # y usa todos los núcleos.

La única debilidad que siempre está terminando debido al límite de enteros 1 << 30.

Java - 88 caracteres

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

Esto permite 2⁶³-1 bucles.

Versión más legible

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

C # - 87 caracteres

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

Versión más legible

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

(Esto está en un sistema de 4 núcleos)

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)

Esto usará el 100% de la CPU en una máquina de un solo núcleo, y con Firefox, tiene la ventaja adicional de que Firefox sigue usando más y más memoria; toda la interfaz se bloquea y la única forma de detenerla es matar a Firefox en el administrador de tareas.

perl, 23 bytes

No puedo entender cómo pegar un control-T literal aquí, así que escribí $ ^ T en su lugar, pero funciona (el literal es 1 char más corto en 23 bytes):

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

$ ^ T es justo el momento en que comenzó el intérprete, por lo que básicamente puede leerlo como time () ya que es lo primero que calculamos.

Python, 30

Encontré este viejo rompecabezas interesante, espero que esté bien publicar una respuesta a una vieja pregunta. Simplemente no podía dejar que las respuestas C vencieran a Python. ;)

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

Esto necesita ajustarse para diferentes CPU, pero no creo que eso viole el OP ... sum(range(2**27))conecta uno de mis núcleos i7 de 2.8GHz por aproximadamente un segundo. :)