Saya telah menemukan sebuah artikel di mana para siswa menggunakan lalu lintas jaringan untuk menggambarkan universitas mereka pada grafik IPv6 negara tersebut . [gambar]

Tujuan Anda sederhana untuk diceritakan, tetapi sulit untuk diimplementasikan. Gambarlah teks MAIL (karena itu adalah salah satu dari beberapa kata yang dapat dibaca pada grafik 1D) pada grafik CPU.

Seharusnya terlihat seperti ini:

Menguraikan sedikit lebih banyak tentang apa yang memenuhi syarat:

• Kode tidak perlu lintas platform (jadi Anda tidak perlu berurusan dengan API yang tidak dikenal).
• Anda dapat menangkapnya di utilitas penggunaan CPU umum yang Anda miliki.
• Grafik terlihat sedikit lebih buruk pada mesin yang berbeda: Saya percaya Anda saat ini.
• % Penggunaan CPU dasar harus kontinu, jadi jika Anda menghasilkan gelombang acak dan menyorot sesuatu yang mirip dengan kata MAIL, itu jelas curang.
• Anda dapat memilih beban maksimum untuk digunakan, tetapi harus cukup substansial untuk melihatnya dengan jelas.
• Anda harus mengikuti linearitas dari contoh. (Untuk M terlihat seperti ini: basis%, lalu peningkatan mendadak ke max yang ditentukan, turun secara bertahap ke% yang lebih rendah, naik kembali ke maks dan tiba-tiba turun ke basis% lagi.)
• Jika tidak dapat dibaca, bagaimanapun juga, pemilih akan melihat.

Celah standar berlaku. Kirimkan gambar juga!

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

Setiap karakter string sesuai dengan satu detik aktivitas, dari karakter ASCII 0(beban maksimum) hingga ~(beban sangat ringan). Program ini berjalan pada loop waktu-disinkronkan, sehingga Anda dapat menjalankan beberapa instance untuk hasil yang lebih bagus.

Saya menggunakan Python 2.7.6 pada OS X dengan Intel Core i7, tetapi harus bekerja pada komputer lain dengan sedikit penyesuaian (sesuaikan 0.001). Tangkapan layar di bawah ini diambil dengan aktivitas latar belakang yang signifikan.

Pembaruan - Saya dapat menghasilkan grafik yang lebih jelas dengan time()/10dan frekuensi pembaruan yang lebih rendah:

Dan akhirnya, inilah versi yang lebih golf ( 123 byte ) dan hasilnya :

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 byte

Monokrom adalah begitu tahun lalu. Ini menggunakan beberapa proses dan syscalls untuk mencapai dua grafik CPU berwarna !

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)

Output dari Activity Monitor (OS X 10.9):

Output dari MenuMeters:

Semua output dihasilkan dengan kecepatan pembaruan 1s. Tidak ada tugas latar belakang yang signifikan yang berjalan, meskipun output ini cukup mudah mengalahkan tugas CPU berulir tunggal.

Kode ini mengasumsikan Anda memiliki 8 core. Seharusnya cukup mudah untuk memodifikasi lebih sedikit / lebih banyak. Ini portabel untuk sistem Linux / UNIX (meskipun hanya diuji pada OS X), dan harus menghasilkan output dua warna yang sama untuk setiap monitor CPU yang dapat membedakan Pengguna dari waktu CPU Sistem.

Pada dasarnya, ini bekerja dengan melepaskan tujuh proses, yang masing-masing akan memilih untuk menghabiskan 1 detik tidur, berputar di usermode, atau memutar kernel. Berputar dalam mode kernel dicapai dengan meminta gumpalan data yang besar /dev/urandom, yang memaksa pengemudi /dev/urandomuntuk menghabiskan banyak siklus CPU "sistem".

DIedit [21/07]: Dipersingkat secara signifikan dengan menggunakan fork()alih-alih multiprocessing.Process( /dev/urandomhanya berfungsi pada sistem * NIX jadi ini tidak mengurangi portabilitas). Namun perlu dicatat bahwa program sekarang memunculkan tugas latar belakang ; Anda mungkin harus killall Python(atau serupa) untuk menyingkirkan pemakan CPU.

Saya tidak bisa menahan diri untuk tidak menerapkan beberapa surat lagi. Saya mendapat 16 surat, ditambah beberapa simbol:

Alfabet lengkapnya adalah "ACDFHILMNOPTUVWY", dengan simbol "._ ~ / \". Mungkin ada lebih banyak karakter yang dapat diwakili.

Kode yang sepenuhnya tidak dipisahkan untuk tambahan surat:

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 byte

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

Kode ini kira-kira portabel seperti Great Pyramid of Cheops. Maaf soal itu. Nilai yang dikembalikan dari mach_absolute_time()tergantung pada perangkat keras, tetapi pada mesin saya nilai bertambah sekitar sekali per nanosecond.

Inilah hasilnya:

Ada dua grafik karena prosesor memiliki dua core. Saya mengatur beban CPU maksimum menjadi sekitar 90% karena proses ini dapat beralih antar core setiap kali saya menelepon usleep(). Dengan muatan 100%, proses dirantai ke satu inti dan hasilnya tidak terbaca ( lihat ini, misalnya )

Ruby, 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}

Sejauh ini tidak terlalu pendek, tapi menurut saya outputnya agak bagus, jadi saya pikir saya akan tetap memposting ini. Seperti kebanyakan solusi lain, Anda mungkin harus menyematkan proses Ruby ke inti tertentu dengan mengawalinya dengan taskset -c $core.

Kode adalah kombinasi sederhana dari spinning / tidur untuk waktu tertentu, yang harus membuatnya agak portabel. Gradien halus dibuat dengan memvariasikan rasio putaran / waktu tidur.

Menurunkan frekuensi pengambilan sampel CPU membuat bagian tepi terlihat sedikit lebih baik:

Dengan menambahkan beberapa huruf lagi ke alfabet ( AILMNUVWagak dapat dikenali), kita juga dapat menulis beberapa kata lain:

Gambar-gambar ini dihasilkan dengan kode berikut:

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
}

Kata-kata yang dapat ditulis dengan huruf yang diimplementasikan dapat ditemukan dengan

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

Python, pada Intel Pentium 4 3.0Ghz, 180 166 145 141 138 byte

Panggil dengan taskset -c 0 python cpu_graph_drawer.py.

taskset diperlukan untuk membatasi proses untuk menggunakan hanya satu CPU / core (hyperthreading dalam kasus saya.)

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)

Hasilnya tidak terlalu bagus.

Java 8, 482 karakter

Setiap karakter dalam String berarti jumlah utas, yang akan digunakan. Gambar diambil pada Intel Core i3 (2 core / 4 utas).

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

Sunting : lebih banyak versi golf (322 karakter), fungsi yang sama:

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 byte

Anda tidak pernah mengatakan kami tidak dapat menerima input pengguna, sooo ..

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

Program ini membaca dari standar dan setiap kali membaca karakter itu mengeksekusi CPU sia-sia untuk loop, kemudian memanggil main lagi. Anda mengontrol jumlah waktu CPU yang digunakan dengan melakukan spam pada tombol enter dengan kecepatan berbeda.

Saya menjalankan ini pada intel i3 4130T, yang merupakan prosesor yang cukup baru. Tetapi jarak tempuh Anda mungkin bervariasi, jika menggunakan waktu CPU lebih banyak atau lebih sedikit daripada yang praktis untuk Anda amati, cobalah bermain dengan jumlah shift dalam loop tunda.

Program saya luar biasa karena:

• sebagian besar lintas platform, itu harus bekerja dengan sangat sedikit mengutak-atik setiap * nix
• mengalahkan pertanyaan itu
• permainan endgame yang bagus

Setelah beberapa kali mencoba saya menghasilkan grafik yang terlihat seperti ini: