introduction

Il existe de nombreux utilitaires capables de créer une charge CPU élevée pour tester vos processeurs. Sous Microsoft Windows, vous pouvez même utiliser la carte intégrée calculator.exe, saisir un grand nombre comme 999999999et appuyer surn! plusieurs fois pour faire fonctionner votre ou vos CPU au fil du temps.

Mais quelle est la solution si vous ne l'avez pas créée vous-même?

La mission

Votre mission - si vous l'acceptez - est de créer le plus petit outil de test de stress CPU de la planète.

Doit…

1. doit produire 100% de charge CPU jusqu'à ce qu'elle soit abandonnée
2. doit prendre une entrée numérique, représentant le nombre de secondes pendant lesquelles le test de résistance doit s'exécuter
3. doit permettre l'interaction de l'utilisateur (pression sur une touche, fermeture de la fenêtre du terminal, ou quelque chose comme ça) qui devrait permettre à un utilisateur d'interrompre le test de résistance et / ou de quitter le programme
4. doit cibler Microsoft Windows, Mac OSx et / ou Linux.
   ^{(Même un hamster pourrait stresser un Comodore64… par conséquent, vous devez cibler un système d'exploitation actuel.)}

Ne doit pas…

1. ne doit pas utiliser de programmes ou d'outils tiers qui remplacent les fonctionnalités attendues.
   ^{(Proposer des raccourcis comme system('cpuStressThing.exe')disqualifie votre proposition.)}

Mai…

1. peut utiliser n'importe quelle approche / algorithme / fonctionnalité pour produire 100% de la charge CPU attendue
2. peut utiliser n'importe quel langage de programmation ou de script
   ^{(tant qu'il permet une vérification pratique de sa fonctionnalité en l'exécutant)}

Condition gagnante

Présentez le code source le plus petit possible. Le gagnant est celui qui présente le code source le plus minimal (en taille) qui respecte les conditions ci-dessus «must» et «must not». Maintenant, fais brûler ce bébé…

MODIFIER

Depuis que la question est apparue dans la zone de commentaire… il vous suffit de cibler 1 cœur de processeur. Je ne m'attends certainement pas à ce que vous produisiez une solution multicœur. Après tout, cela devrait être amusant - pas travailler.

Utilitaires Bash et standard, 36 31 22 29 28 26 octets

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

Bash / iputils (Linux), 14 octets

ping6 -fw$1 ::

Flood-pings l'adresse nulle IPv6, jusqu'à l'expiration du délai -w

mise en garde - ne consomme que 55 à 60% de CPU sur ma machine virtuelle de test

Edit: - Je retire ma mise en garde. Alors que les toprapports indiquent que le ping6processus ne consomme que 55 à 60% de CPU, je vois le pourcentage d'inactivité total du CPU (VM à 2 cœurs) approcher de zéro. Cela est probablement dû au fait qu'une grande partie du traitement est en cours dans le noyau pendant qu'il gère les paquets.

Remarque - doit être exécuté en tant que root. Comme le commente @Tobia, cela semble être une exigence raisonnable pour quelque chose qui monopolise le processeur. Et le PO l'a approuvé dans les commentaires.

Elf32 binaire autonome - 86 octets

Je parie que c'est le plus petit binaire au format Elf correctement formé qui peut être fait pour exécuter cette fonction. Cela s'exécutera sans aucun support supplémentaire sur n'importe quelle plate-forme basée sur Linux, ou potentiellement même sans système d'exploitation .

Téléchargement binaire: http://ge.tt/3m6h2cK1/v/0?c

Vidage hexadécimal:

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.

Cela se fait en créant un fichier asm avec un en-tête Elf minimal et en ignorant ldcomplètement l'utilisation de .

Assemblée:

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

Construit avec nasm -f bin tiny_cpu_stresser_elf32.asm -o tiny_cpu_stresser_elf32

bash builtins seulement 20 octets

ulimit -t $1;exec $0

C, 52

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

Appuyez sur Ctrl + C pour quitter.

Perl, 32

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

Maintenant, la partie embarrassante: je me suis mis bêtement $t=timedevant $i=<>et essayais furieusement de comprendre pourquoi il sortait quelques secondes plus tôt.

Encore une fois, Ctrl + C pour quitter.

Unix C, 47

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

Passez le temps sur la ligne de commande. La touche d'interruption (Ctrl-C) s'interrompt.

Smalltalk (Smalltalk / X), 34

entrée: n; interrompre avec CTRL-c ou CMD-.

[[]loop]valueWithTimeout:n seconds

peut mieux jouer au golf, si mesuré en jours ;-) (je plaisante):

[[]loop]valueWithTimeout:n days

ou à partir d'une ligne de commande:

Ce n'est pas une tentative sérieuse, mais ...

Bash, 12 octets

:(){ :|:&};:

Comme on le trouve sur Wikipédia .

ATTENTION: code nuisible, ne l'exécutez pas sur votre ordinateur!

Techniquement:
- Il produit 100% de charge CPU jusqu'à ce que le système plante;
- Permet l'interaction de l'utilisateur pour l'arrêter (si vous parvenez à tuer toutes les fourches, vous pouvez réellement l'arrêter ...);
- Vous pouvez lui donner une entrée numérique qui représente le nombre de secondes qu'il doit exécuter, mais il ne l'utilisera pas.

PHP 43 40 octets:

J'espère que c'est une réponse acceptable:

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

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

Je pourrais faire comme ça: <?for(set_time_limit($_POST['t']);;);mais cela perdrait de la flexibilité et 3 octets.

Et je pourrais tricher et faire comme ceci: <?for(set_time_limit($_REQUEST[t]);;);. Il rase 2 octets, mais ce n'est pas une solution "standard". Permet de garder le jeu équitable.

Comme l'ont suggéré @fireeyedboy et @primo, vous pouvez également utiliser cette solution (34 octets):

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

Cela permet son utilisation à partir de la console, en l'appelant comme ceci:

php <filename> <time in seconds>

Comme je l'ai dit, je ne cible pas la solution de console, mais ils doivent obtenir le crédit pour celle-ci.

Une autre réponse pourrait être ce "monstre", qui n'est que les deux réponses combinées:

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

Il est impossible d'obtenir des pressions de touches en php, sans être sur la console, que je ne cible pas!

Pour l'arrêter, vous DEVEZ abandonner le processus (arrêter le chargement de la page peut arrêter le code)!

En plus, cela fonctionne aussi sur Android! Si vous installez un serveur php (gratuit sur Google Play).

Pour le faire fonctionner, faites simplement ceci:

Vous créez une page Web .php et ajoutez ?t=<time in seconds>à la fin de l'URL ou soumettez un message (en utilisant un formulaire ou même ajax).

BrainFuck / BrainFuck étendu : 3

+[]

Il utilisera 100% cpu sur un cœur jusqu'à ce qu'il soit abandonné. Tous les programmes Brainfuck sont des programmes EBF valides.

Zozotez LISP : 7 15 19

Lors de l'utilisation du petit pilote.

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

En tant qu'expression autonome sans pilote: 15

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

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

Perl - 14 octets

alarm<>;{redo}

Définit a SIGALRMà envoyerinput quelques secondes, ce qui met fin au script. En attendant, il tourne dans une attente occupée.

Exemple d'utilisation:

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

Perl - 12 (+1) octets

Si les options de ligne de commande sont comptées comme un octet chacune, cela pourrait être réduit à 13 octets en utilisant -n:

alarm;{redo}

Exemple d'utilisation:

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

Assemblage x86_64 sur Linux - 146 (source), 42 (code assemblé)

La source minifiée NASM (146 octets):

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

Accepte un paramètre sur la ligne de commande spécifiant le nombre de secondes à exécuter dans la plage (0, 9999999]; peut être interrompu avec le Ctrl-C habituel.

Vous pouvez l'assembler avec

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

En théorie, il faudrait ajouter un global _startsuivi d'un _start:label au début, mais ldparvient à le réparer lui-même avec peu de bruit.

Le code machine correspondant (42 octets):

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

(généré avec l' nasmajout de la BITS 64directive)

Une version un peu plus lisible:

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

Python, 58 55 51

Wow ... plus long que le C. Il doit y avoir un meilleur moyen. Encore un peu long, mais au moins ça bat la solution C!

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

Java - 154 148 186

Une erreur bizarre a mangé ma 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);}}

et une version plus lisible:

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

Génère un new Threadavec une belle boucle sans fin ( for(;;);) puis sur le thread principal a thread.sleep()et un System.exit(0)délai d'attente pour quitter; ctrl-c se ferme également sur cmdline exit(). s'écraser ne fonctionnera pas;

Lot, 2 caractères

%0

En substance, le programme recommence sans cesse. Vos résultats peuvent varier en raison de la priorité d'allocation des tâches du processeur, mais cela fonctionne pour moi.

Powershell, 18 54 50 octets

Pour produire 100% de charge pour tous les cœurs de CPU.

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

• Le script prend un temps en secondes comme argument.
• | AddS*est le raccourci pour la .AddSeconds()méthode.
• sajbest l'alias de l' Start-Jobapplet de commande.

Linux sh et utilitaires standard, 14

Gnu coreutils récent inclut un timeoututilitaire qui est utile:

 timeout $1 yes

Matlab - 19

tic;while toc<5;end

Remplacez 5par le temps d'exécution souhaité.

Aller, 215 212 193 octets (complet)

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, souligne tous les CPU.

Le Now()dans la boucle est là pour lancer le planificateur,Now était le nom de fonction le plus court que j'ai pu trouver dans mon espace de noms

Si je lance go fmtla taille augmente à 286 277 254 octets

Bash: 19 caractères

function f(){ f;};f

Assemblage: 16 octets

_start:jg _start

Edit: N'ayant pas remarqué la nécessité de prendre une entrée numérique, je vais prétendre qu'elle en prend une sur la ligne de commande, mais l'ignore =)

Lot DOS - 5 octets

%0|%0

Lot DOS - 8 octets

%0|%0&%0

La seconde est une traduction de l'infâme fourche sh.

Ctrl + C interrompt le programme (sauf si vous avez légèrement modifié les paramètres).

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

Non compressé

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

Cela nécessite un nombre comme argument qui est le nombre de secondes à exécuter. Il utilisera 100% d'un cœur pendant autant de temps ou jusqu'à crtl + c. Je suis sûr que c'est aussi petit que C # ira avec sa verbosité.

C # - 178 caractères

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

Et plus lisible:

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

C'est 178 caractères en C # et utilise tous les cœurs.

La seule faiblesse qu'il finit toujours à cause de la limite de 1 << 30 entier.

Java - 88 caractères

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

Cela permet des boucles de 2⁶³-1.

Version plus lisible

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

C # - 87 caractères

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

Version plus lisible

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

(Ceci est sur un système à 4 cœurs)

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)

Cela utilisera 100% du CPU sur une machine monocœur, et avec Firefox, il a le bonus supplémentaire que Firefox continue à utiliser de plus en plus de mémoire; toute l'interface se bloque et la seule façon de l'arrêter est de tuer Firefox dans le gestionnaire de tâches.

perl, 23 octets

Je ne peux pas comprendre comment coller un littéral control-T ici, j'ai donc tapé $ ^ T à la place, mais l'un ou l'autre fonctionne (le littéral est 1 caractère plus court à 23 octets):

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

$ ^ T est juste l'heure à laquelle l'interpréteur a commencé, vous pouvez donc le lire comme time () car c'est la première chose que nous calculons.

Python, 30

J'ai trouvé ce vieux puzzle intéressant, j'espère que c'est OK pour poster une réponse à une vieille question. Je ne pouvais tout simplement pas laisser les réponses C battre Python. ;)

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

Cela doit être réglé pour différents processeurs, mais je ne pense pas que cela viole l'OP ... fixe sum(range(2**27))un de mes cœurs i7 à 2,8 GHz pendant environ une seconde. :)