Je suis tombé sur un article dans lequel des étudiants utilisaient le trafic réseau pour dessiner leur université sur le graphique IPv6 du pays . [image]

Votre objectif est simple à dire, mais difficile à mettre en œuvre. Dessinez le texte MAIL (car il s’agit de l’un des rares mots pouvant être lus sur un graphique 1D) sur le graphique de la CPU.

Ça devrait ressembler a quelque chose comme ca:

En élaborant un peu plus sur ce qui est admissible:

• Le code n'a pas besoin d'être multiplate-forme (vous n'aurez donc pas besoin d'API inconnues pour y faire face).
• Vous pouvez le capturer dans n'importe quel utilitaire d'utilisation du processeur que vous avez.
• Le graphique semble un peu pire sur une machine différente: je vous fais confiance cette fois-ci.
• Le pourcentage d'utilisation du processeur de base doit être continu. Par conséquent, si vous générez une onde aléatoire et mettez en surbrillance un élément qui ressemble au mot MAIL, il est évident que vous trichez.
• Vous pouvez choisir la charge maximale à utiliser, mais celle-ci doit être suffisamment importante pour la voir clairement.
• Vous devez suivre la linéarité de l'exemple. (Pour M, cela ressemble à ceci:% de base, puis augmentation soudaine jusqu'au maximum spécifié, baisse graduelle vers un% inférieur, remontant au maximum et baisse soudaine jusqu'au% de base.)
• Si c'est illisible, les électeurs le remarqueront après tout.

Les failles standard s'appliquent. Postez les images aussi!

Python, 143

from time import*
while 1:
 sleep((ord('00012345654321000~~~D:6300036:D~~~000~~~000DDDD~~~~~'[int(time())%52])-48)*0.001);x=10**5
 while x:x-=1

Chaque caractère de la chaîne correspond à une seconde d'activité, du caractère ASCII 0(charge maximale) à ~(charge très légère). Le programme s'exécute sur une boucle synchronisée dans le temps, vous pouvez donc exécuter plusieurs instances pour obtenir de meilleurs résultats.

J'ai utilisé Python 2.7.6 sur OS X avec un processeur Intel Core i7, mais cela devrait fonctionner sur d'autres ordinateurs avec un peu d'ajustement (réglez la 0.001). La capture d'écran ci-dessous a été prise avec une activité de fond importante.

Mise à jour - J'ai été en mesure de produire un graphique plus clair avec time()/10une fréquence de mise à jour inférieure:

Et enfin, voici une version plus golfée ( 123 octets ) et son résultat :

from time import*
while 1:
 sleep((ord('002464200~~A5005A~~00~~00DDD~~'[int(time()/2)%30])-48)*0.001);x=10**5
 while x:x-=1

Python, 358 281 268 221 194 octets

Monochrome est tellement l'année dernière. Cela utilise plusieurs processus et appels système pour obtenir des graphiques de processeur à deux couleurs !

import os,time
A='%-99o'%int('t12q2lxqkap48euoej9429cstbnazl63ubyryteo49u',36)
for i in'0123456':
 t=os.fork()
 while t<1:T=int(time.time())%50;(time.sleep,(id,os.urandom)[i<A[T+49]])[i<A[T]](1)

Sortie du moniteur d’activités (OS X 10.9):

Sortie de MenuMeters:

Toutes les sorties ont été générées avec une vitesse de mise à jour de 1s. Aucune tâche d’arrière-plan importante n’était en cours d’exécution, bien que cette sortie vainc assez facilement toute tâche de processeur à un seul thread.

Ce code suppose que vous avez 8 cœurs. Il devrait être assez facile de modifier pour moins / plus. Il est portable sur les systèmes Linux / UNIX (bien qu'il n'ait été testé que sur OS X) et devrait produire la même sortie bicolore pour tout moniteur de CPU capable de distinguer l'utilisateur du temps UC du système.

Cela fonctionne essentiellement en supprimant sept processus, chacun choisissant de passer une seconde en veille, en tournant dans le mode utilisateur ou en faisant tourner le noyau. Le spin en mode noyau est obtenu en demandant de grandes quantités de données /dev/urandom, ce qui oblige le back-up du pilote /dev/urandomà passer beaucoup de cycles de la CPU "système".

EDITED [07/21]: Réduit considérablement en utilisant à la fork()place de multiprocessing.Process( /dev/urandomne fonctionne de toute façon que sur les systèmes * NIX, cela ne réduit donc pas la portabilité). Notez cependant que le programme génère maintenant des tâches en arrière-plan ; vous devrez peut-être killall Python(ou similaire) pour vous débarrasser des mangeurs de CPU.

Je n'ai pas pu résister à la mise en place de quelques lettres supplémentaires. J'ai 16 lettres, plus quelques symboles:

L'alphabet complet est "ACDFHILMNOPTUVWY", avec les symboles "._ ~ / \". Il y a probablement beaucoup plus de personnages qui peuvent être représentés.

Code entièrement non-golfé pour les lettres supplémentaires:

from time import*
from multiprocessing import*

chars6 = {
'A': ('123456654321',
      '000123321000'),
'C': ('344556666666',
      '321110000000'),
'D': ('666666655443',
      '000000011123'),
'F': ('66666666666666',
      '00002222244444'),
'H': ('666664444466666',
      '000002222200000'),
'I': ('66666',
      '00000'),
'L': ('666662222222',
      '000000000000'),
'M': ('6665544334455666',
      '0004321001234000'),
'N': ('66665544336666',
      '00003322110000'),
'O': ('3445556666555443',
      '3221110000111223'),
'P': ('666666666555',
      '000003333444'),
'T': ('777776666677777',
      '444440000044444'),
'U': ('6666322236666',
      '4211000001124'),
'V': ('66654322345666',
      '33321000012333'),
'W': ('66542466424566',
      '43210133101234'),
'Y': ('66665433456666',
      '44333000033344'),
'_': ('1111111111',
      '0000000000'),
' ': ('000',
      '000'),
'.': ('12221',
      '10001'),
'~': ('44445544334444',
      '11223322112233'),
'/': ('2234566',
      '0012344'),
'\\': ('6654322',
       '4432100'),
}

s = 'ANCHOVY '
A = '000'.join(chars6[t][0] for t in s)
B = '000'.join(chars6[t][1] for t in s)

t=time()
f=open('/dev/urandom')
def F(n):
 while 1:T=int(time()-t)%len(A);[sleep,[].count,lambda x:f.read(4**9)][(n<int(A[T]))+(n<int(B[T]))](1)
for i in range(7):Process(target=F,args=(i,)).start()
F(7)

C (Intel Core Duo + OS X / Darwin), 248 octets

#include <unistd.h>
#include <mach/mach_time.h>
#define M mach_absolute_time()
main(){char*s="JJJIHGFGHIJJJ@BDFHJJJHFDB@JJJJ@JJJJBBBBBBB";uint64_t i,t,y=1;for(;*s;s++){
for(i=40;i;i--){for(t=M+(*s&15)*9090909;t>M;)y*=7;usleep((11-(*s&15))*9091);}}}

Ce code est à peu près aussi portable que la Grande Pyramide de Kheops. Désolé pour ça. Les valeurs renvoyées mach_absolute_time()dépendent du matériel, mais sur ma machine, la valeur incrémente environ une fois par nanoseconde.

Voici le résultat:

Il y a deux graphiques car le processeur a deux cœurs. Je règle la charge maximale du processeur sur environ 90%, car le processus est susceptible de basculer entre les cœurs chaque fois que j'appelle usleep(). Avec une charge de 100%, le processus est enchaîné et les résultats sont illisibles ( voir ceci, par exemple )

Ruby, 150 caractères

a=(0..15).map{|i|[0.9-3*i*=0.02,i]}
[9,*a[0,11],*(z=a.reverse)[5,11],11,*z,*a,2,11,6,*[0.2]*9].map{|x,y|c=Time.now
1until Time.now-c>x/3
sleep y||x%3}

Ce n’est pas si court jusqu’à présent, mais à mon avis, la sortie est plutôt sympa, alors j’ai pensé que je posterais ça de toute façon. Comme avec la plupart des autres solutions, vous devrez peut-être épingler le processus Ruby à un noyau en le préfixant avec taskset -c $core.

Le code est une simple combinaison de rotation / sommeil pendant un certain temps, ce qui devrait le rendre assez portable. Les dégradés lisses sont créés en faisant varier le rapport temps de rotation / sommeil.

La diminution de la fréquence d'échantillonnage du processeur améliore l'aspect des bords:

En ajoutant quelques lettres supplémentaires à l’alphabet (qui AILMNUVWsont plus ou moins reconnaissables), nous pouvons aussi écrire quelques autres mots:

Ces images ont été générées avec le code suivant:

def gradient num_samples, direction, base = 0.3, increment = 0.02, scale = 1
    range = [*0..num_samples]

    samples = case direction
        when :up then range.reverse
        when :down then range
        when :updown then range.reverse + range
        when :downup then range + range.reverse
    end

    samples.map{|i|
        i *= increment
        [base - scale * i, i]
    }
end

# letters are defined as a series of pairs of (spin-time, sleep-time)
# with the time in seconds
THIN_A = gradient(15, :updown, 0.2, 0.2/15)
A = gradient(15, :updown)
I = 2,0
L = 1.5,0, [[0.1,0.2]]*9
M = 2,0, gradient(9, :downup), 2,0
N = 1,0, gradient(9, :down), 2,0
U = 1,0, gradient(9, :downup, 0.1, 0.03, 0.1), 1,0
V = 0.5,0, gradient(12, :downup, 0.25, 0.02), 0.5,0
W = 0.5,0, [gradient(12, :downup, 0.25, 0.02)]*2, 0.5,0

[A,I,L,M,N,U,V,W].map{|i|
    # add 2 second pause after each letter
    i + [0,2]
}.flatten.each_slice(2){|x,y|
    # spin, then sleep
    c = Time.now
    1 until Time.now-c > x
    sleep y
}

Les mots pouvant être écrits avec les lettres implémentées peuvent être trouvés avec

grep -E '^[aijlmnuvw]+$' /usr/share/dict/words 

Python, sur Intel Pentium 4 3.0Ghz, 180 166 145 141 138 octets

Appeler avec taskset -c 0 python cpu_graph_drawer.py.

taskset est nécessaire pour restreindre le processus à l’utilisation d’un seul processeur / cœur (hyperthreading dans mon cas).

from time import*;c=clock
a=[(3,.8),(3,5),(4,5),(1.3,5),(1.3,0)]
a.extend([(.1,.2)]*10)
for x,y in a:
    t=c()
    while c()-t<x:pass
    sleep(y)

Le résultat n'est pas terrible.

Java 8, 482 caractères

Chaque caractère de la chaîne signifie le nombre de threads à utiliser. Image prise sur Intel Core i3 (2 cœurs / 4 threads).

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public class Mail{
public static void main(String[] args) throws InterruptedException{
Thread.sleep(15000);
for(char c:"123432234321000012343210000444000044441111111".toCharArray()){
ExecutorService executorService = Executors.newScheduledThreadPool(4);
for(int i=1;i<c-48;i++)executorService.execute(()->{while(!Thread.interrupted());});
Thread.sleep(1500);
executorService.shutdownNow();
}}}

Edit : version plus golfée (322 caractères), même fonctionnalité:

import java.util.concurrent.*;
class M{
public static void main(String[]a)throws Exception{
for(int c:"123432234321000012343210000444000044441111111".toCharArray()){
ExecutorService s=Executors.newFixedThreadPool(4);
while(c>48){c--;s.execute(()->{while(!Thread.interrupted());});}
Thread.sleep(1500);
s.shutdownNow();
}}}

C, 78 octets

Vous n'avez jamais dit que nous ne pouvions pas accepter les entrées de l'utilisateur, sooo ..

#include <unistd.h>
int main(){int x=0;for(;x<1<<26;++x);read(0,&x,1);main();}

Ce programme lit en standard et chaque fois qu’il lit un caractère, il exécute une perte de temps CPU gratuite, puis appelle de nouveau principal. Vous contrôlez la quantité de temps CPU utilisé en envoyant un spam à la touche Entrée à différentes vitesses.

Je l'ai couru sur un Intel i3 4130T, qui est un processeur raisonnablement nouveau. Toutefois, votre kilométrage peut varier. Si vous utilisez plus de temps processeur que vous ne pouvez le faire, essayez de jouer avec la quantité de décalage dans la boucle de délai.

Mon programme est génial car il:

• est principalement cross-platform, cela devrait fonctionner avec très peu de violon sur n'importe quel * nix
• défait la question
• super jeu en fin de partie

Après quelques essais, j'ai créé un graphique ressemblant à ceci: