Öğrencilerin üniversitelerini ülkenin IPv6 grafiğine çekmek için ağ trafiğini kullandıkları bir makaleyle karşılaştım . [Görüntü]

Amacınız anlatması basit ama gerçekleştirmesi zor. CPU grafiğinde MAIL metnini çizin (bir 1D grafikte okunabilen birkaç kelimeden biri olduğu gibi).

Bunun gibi bir şeye benzemeli:

Nitelikler konusunda biraz daha ayrıntılı:

• Kodun platformlar arası olması gerekmez (bu yüzden başa çıkmak için bilinmeyen API'lere ihtiyacınız olmaz).
• Sahip olduğunuz herhangi bir genel CPU kullanım yardımcı programında yakalayabilirsiniz.
• Grafik farklı bir makinede biraz daha kötü görünüyor: Bu sefer sana güveniyorum.
• Temel CPU kullanımı% 'si sürekli olmalıdır, bu nedenle rastgele bir dalga üretir ve MAIL kelimesine benzeyen bir şeyi vurgularsanız, açıkça aldatma olur.
• Kullanılacak maksimum yükü seçebilirsiniz, ancak açıkça görebilecek kadar büyük olması gerekir.
• Örneğin doğrusallığını izlemelisiniz. (M için şöyle görünür: baz%, sonra belirtilen maksimuma ani artış, kademeli olarak% azalmaya, tekrar maksimuma ve ani düşüşe tekrar baz% 'e düşer.)
• Okunamıyorsa, seçmenler sonuçta farkedecektir.

Standart boşluklar uygulanır. Görüntüleri de yayınla!

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

Dizenin her karakteri ASCII karakterinden 0(maks. Yük) kadar ~(çok hafif yük) kadar bir saniyelik aktiviteye karşılık gelir . Program zaman senkronize bir döngüde çalışır, böylece daha iyi sonuçlar için birden fazla örnek çalıştırabilirsiniz.

OS X'te Python 2.7.6'yı Intel Core i7 ile kullandım, ancak biraz daha fazla ayarlanan diğer bilgisayarlarda da çalışması gerekiyor (düzeltin 0.001). Aşağıdaki ekran görüntüsü kayda değer arka plan etkinliği ile alınmıştır.

Güncelleme - Daha net time()/10bir güncelleme ve daha düşük bir güncelleme sıklığı üretebildim :

Ve son olarak, işte daha çok golf oyunları ( 123 bytes ) ve sonucu :

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 bayt

Tek renkli olan bu yüzden geçen yıl. Bu, iki renkli CPU grafiğini elde etmek için çoklu işlemler ve sistemler kullanır !

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)

Aktivite İzleyiciden Çıktı (OS X 10.9):

MenuMeters'tan Çıktı:

Tüm çıktılar 1 saniyelik güncelleme hızında üretildi. Hiçbir önemli arka plan görevi yürütülmüyordu, ancak bu çıktı tek bir iş parçacıklı CPU görevini kolayca atıyor.

Bu kod 8 çekirdeğiniz olduğunu varsayar. Daha az / daha fazla değişiklik yapmak oldukça kolay olmalı. Öyle taşınabilir (yalnızca OS X üzerinde test edilmiştir rağmen) Linux / UNIX sistemlerine ve Sistem CPU zaman Kullanıcı ayırt edebilir herhangi bir CPU monitör için aynı iki renkli çıktı üretmelidir.

Temel olarak, bu işlem, her biri 1 saniye uyku geçirmeyi, kullanıcı modunu eğirmeyi veya çekirdeği eğmeyi seçmeyi planlayan yedi işlemi onaylayarak çalışır. Çekirdek modunda dönme /dev/urandom, sürücünün desteğini /dev/urandomçok sayıda "sistem" CPU döngüsü harcamasına zorlayan büyük miktarda veri istemek suretiyle elde edilir .

EDITED [07/21]: Kullanmak fork()yerine önemli ölçüde kısaltıldı multiprocessing.Process( /dev/urandomyalnızca * NIX sistemlerinde çalışıyor, bu da taşınabilirliği azaltmıyor). Bununla birlikte, programın artık arka plan görevlerini ortaya koyduğunu unutmayın ; killall PythonCPU-yiyicilerden kurtulmak için gerekebilir (veya benzer).

Birkaç harften daha fazla yararlanamadım. 16 harf ve bir kaç sembol aldım:

Alfabenin tamamı "ACDFHILMNOPTUVWY", "._ ~ / \" sembolleriyledir. Muhtemelen temsil edilebilecek çok daha fazla karakter var.

Ekstra harfler için tamamen kodlanmamış kod:

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 + İşletim Sistemi X / Darwin), 248 bayt

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

Bu kod, Cheops Büyük Piramidi kadar taşınabilir. Bunun için üzgünüm. Döndürülen değerler mach_absolute_time()donanıma bağlıdır, ancak makinemde değer her nanosaniye başına bir kez artar.

İşte sonuç:

İşlemci iki çekirdeğe sahip olduğundan iki grafik vardır. Maksimum CPU yükünü yaklaşık% 90 olarak belirledim, çünkü işlem her çağrıldığında çekirdekler arasında geçiş yapmakla yükümlü usleep(). % 100 yük ile işlem bir çekirdeğe zincirlenir ve sonuçlar okunaksızdır ( örneğin, buna bakınız )

Yakut, 150 karakter

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}

Şimdiye kadar bu kadar kısa değil, ama bence çıktı oldukça iyi, bu yüzden bunu yine de göndereceğimi düşündüm. Diğer çözümlerin çoğunda olduğu gibi, Ruby işlemini önek ekleyerek belirli bir çekirdeğe sabitlemeniz gerekebilir taskset -c $core.

Kod, belli bir süre için basitçe döndürme / uyuma kombinasyonudur; bu, biraz taşınabilir olmalıdır . Dönme / uyku zamanının oranı değiştirilerek düzgün degradeler oluşturulur.

CPU örnekleme frekansını düşürmek kenarların biraz daha iyi görünmesini sağlar:

Alfabeye birkaç harf daha ekleyerek ( AILMNUVWbiraz tanınabilir), başka kelimeler de yazabiliriz:

Bu resimler aşağıdaki kodla üretildi:

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
}

Uygulanan harflerle yazılabilecek kelimeler

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

Python, Intel Pentium 4'te 3.0GHz, 180 166 145 141 138 bayt

İle arayın taskset -c 0 python cpu_graph_drawer.py.

taskset İşlemi yalnızca bir CPU / çekirdek kullanmasını sınırlamak için gereklidir (benim durumumda hiper iş parçacığı.)

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)

Sonuç o kadar da iyi değil.

Java 8, 482 karakter

String'deki her karakter kullanılacak olan iplik sayısını ifade eder. Intel Core i3'te çekilen resim (2 çekirdek / 4 adet).

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

Düzenleme : daha golflü versiyonu (322 karakter), aynı işlevsellik:

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 bayt

Kullanıcı girişini kabul edemeyeceğimizi asla söylemedin, sooo.

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

Bu program standart olarak okur ve bir karakter okursa, döngü için boş bir CPU boşa harcar, sonra tekrar ana çağırır. Enter tuşunu farklı hızlarda spam yaparak kullandığı CPU zamanı miktarını kontrol edersiniz.

Bunu, oldukça yeni bir işlemci olan intel i3 4130T ile yaptım. Ancak kilometreniz değişebilir, eğer gözlemlemeniz için pratikten daha az veya daha fazla CPU kullanıyorsa, gecikme döngüsündeki vardiya miktarıyla oynamayı deneyin.

Programım harika çünkü o:

• çoğunlukla çapraz platformdur, herhangi bir * nix üzerinde çok az işe yaramayabilir
• soruyu yener
• harika oyun sonu oyunu

Birkaç denemeden sonra şuna benzeyen bir grafik hazırladım: