Tôi đã bắt gặp một bài báo nơi sinh viên sử dụng lưu lượng mạng để vẽ trường đại học của họ trên biểu đồ IPv6 của đất nước . [Hình ảnh, tưởng tượng]

Mục tiêu của bạn là đơn giản để nói, nhưng khó thực hiện. Vẽ văn bản MAIL (vì đây là một trong số ít các từ có thể đọc được trên biểu đồ 1D) trên biểu đồ CPU.

Nó sẽ trông giống như thế này:

Xây dựng thêm một chút về những gì đủ điều kiện:

• Mã không cần phải đa nền tảng (vì vậy bạn sẽ không cần các API không xác định để xử lý).
• Bạn có thể nắm bắt nó trong bất kỳ tiện ích sử dụng CPU chung nào mà bạn có.
• Biểu đồ trông hơi tệ hơn trên một máy khác: Tôi tin bạn lần này.
• % Sử dụng CPU cơ sở phải liên tục, vì vậy nếu bạn tạo một sóng ngẫu nhiên và làm nổi bật một cái gì đó trông giống như từ MAIL, thì rõ ràng là gian lận.
• Bạn có thể chọn tải tối đa để sử dụng, nhưng nó phải đủ lớn để thấy rõ nó.
• Bạn phải tuân theo tính tuyến tính của ví dụ. (Đối với M, nó trông như thế này:% cơ sở, sau đó tăng đột ngột đến mức tối đa được chỉ định, giảm dần xuống% thấp hơn, tăng trở lại mức tối đa và giảm đột ngột xuống% cơ sở một lần nữa.)
• Nếu không thể đọc được, cử tri sẽ chú ý sau tất cả.

Tiêu chuẩn áp dụng. Đăng hình ảnh quá!

Con trăn, 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

Mỗi ký tự của chuỗi tương ứng với một giây hoạt động, từ ký tự ASCII 0(tải tối đa) đến ~(tải rất nhẹ). Chương trình chạy trên một vòng lặp được đồng bộ hóa thời gian, vì vậy bạn có thể chạy nhiều phiên bản để có kết quả đẹp hơn.

Tôi đã sử dụng Python 2.7.6 trên OS X với Intel Core i7, nhưng nó sẽ hoạt động trên các máy tính khác với một chút tinh chỉnh (điều chỉnh 0.001). Ảnh chụp màn hình dưới đây được chụp với hoạt động nền quan trọng.

Cập nhật - Tôi đã có thể tạo một biểu đồ rõ ràng hơn time()/10và tần suất cập nhật thấp hơn:

Và cuối cùng, đây là một phiên bản được chơi nhiều hơn ( 123 byte ) và kết quả của nó :

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

Đơn sắc là như vậy năm ngoái. Điều này sử dụng nhiều quy trình và tòa nhà để đạt được hai biểu đồ CPU màu !

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)

Đầu ra từ Trình giám sát hoạt động (OS X 10.9):

Đầu ra từ MenuMeter:

Tất cả các kết quả đầu ra được tạo ra với tốc độ cập nhật là 1 giây. Không có tác vụ nền quan trọng nào đang chạy, mặc dù đầu ra này khá dễ dàng vượt qua mọi tác vụ CPU đơn luồng.

Mã này giả sử bạn có 8 lõi. Nó sẽ khá dễ dàng để sửa đổi cho ít / nhiều hơn. Nó có thể di chuyển tới các hệ thống Linux / UNIX (mặc dù nó mới chỉ được thử nghiệm trên OS X) và sẽ tạo ra cùng một đầu ra hai màu cho bất kỳ màn hình CPU nào có thể phân biệt Người dùng với thời gian CPU của Hệ thống.

Về cơ bản, điều này hoạt động bằng cách loại bỏ bảy quy trình, mỗi quy trình sẽ chọn dành 1 giây để ngủ, quay trong usermode hoặc quay kernel. Việc quay vòng trong chế độ kernel đạt được bằng cách yêu cầu các luồng dữ liệu lớn từ /dev/urandomđó, điều này buộc người lái /dev/urandomphải lùi nhiều chu kỳ CPU "hệ thống".

EDITED [21/07]: Rút ngắn đáng kể bằng cách sử dụng fork()thay vì multiprocessing.Process( /dev/urandomchỉ hoạt động trên các hệ thống * NIX vì vậy điều này không làm giảm tính di động). Tuy nhiên, lưu ý rằng chương trình hiện sinh ra các tác vụ nền ; bạn có thể phải killall Python(hoặc tương tự) để loại bỏ những kẻ ăn CPU.

Tôi không thể cưỡng lại việc thực hiện thêm một vài chữ cái. Tôi đã nhận được 16 chữ cái, cộng với một vài ký hiệu:

Bảng chữ cái hoàn chỉnh là "ACDFHILMNOPTUVWY", với các ký hiệu "._ ~ / \". Có lẽ có rất nhiều nhân vật có thể được đại diện.

Mã hoàn toàn vô căn cứ cho các chữ cái thêm:

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

Mã này có khả năng di động như Đại kim tự tháp Cheops. Xin lỗi vì điều đó. Các giá trị được trả về mach_absolute_time()phụ thuộc vào phần cứng, nhưng trên máy của tôi, giá trị tăng khoảng một lần mỗi nano giây.

Đây là kết quả:

Có hai biểu đồ vì bộ xử lý có hai lõi. Tôi đặt tải CPU tối đa là khoảng 90% vì quá trình này có thể chuyển đổi giữa các lõi bất cứ khi nào tôi gọi usleep(). Với tải 100%, quy trình được kết nối thành một lõi và kết quả là không thể thực hiện được ( xem ví dụ này )

Ruby, 150 ký tự

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}

Đây không phải là tất cả quá ngắn cho đến nay, nhưng theo tôi thì đầu ra khá đẹp, vì vậy tôi nghĩ rằng dù sao tôi cũng sẽ đăng bài này. Như với hầu hết các giải pháp khác, bạn có thể phải ghim quy trình Ruby vào một lõi nhất định bằng cách thêm tiền tố vào taskset -c $core.

Mã này là một sự kết hợp đơn giản của quay / ngủ trong một khoảng thời gian nhất định, điều này sẽ làm cho nó có phần di động. Độ dốc mịn được tạo ra bằng cách thay đổi tỷ lệ thời gian quay / ngủ.

Giảm tần số lấy mẫu CPU làm cho các cạnh trông tốt hơn một chút:

Bằng cách thêm một vài chữ cái vào bảng chữ cái ( AILMNUVWcó thể dễ nhận ra), chúng ta cũng có thể viết một số từ khác:

Những hình ảnh này được tạo ra với mã sau đây:

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
}

Các từ có thể được viết bằng các chữ cái được triển khai có thể được tìm thấy với

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

Python, trên Intel Pentium 4 3.0Ghz, 180 166 145 141 138 byte

Gọi với taskset -c 0 python cpu_graph_drawer.py.

taskset là cần thiết để hạn chế quá trình chỉ sử dụng một CPU / lõi (siêu phân luồng trong trường hợp của tôi.)

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)

Kết quả không phải là tuyệt vời.

Java 8, 482 ký tự

Mỗi ký tự trong Chuỗi có nghĩa là số lượng chủ đề, sẽ được sử dụng. Hình ảnh được chụp trên Intel Core i3 (2 lõi / 4 luồng).

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

Chỉnh sửa : phiên bản nhiều gôn hơn (322 ký tự), cùng chức năng:

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

Bạn không bao giờ nói rằng chúng tôi không thể chấp nhận đầu vào của người dùng, vì vậy ..

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

Chương trình này đọc từ tiêu chuẩn và mỗi khi đọc một ký tự, nó thực thi một CPU lãng phí cho vòng lặp, sau đó gọi lại chính. Bạn kiểm soát lượng thời gian CPU sử dụng bằng cách spam phím enter ở các tốc độ khác nhau.

Tôi đã chạy nó trên intel i3 4130T, đây là một bộ xử lý hợp lý mới. Nhưng số dặm của bạn có thể thay đổi, nếu nó sử dụng thời gian CPU nhiều hơn hoặc ít hơn thực tế để bạn quan sát, hãy thử chơi với số lượng thay đổi trong vòng lặp trễ.

Chương trình của tôi thật tuyệt vời vì nó:

• chủ yếu là đa nền tảng, nó sẽ hoạt động với rất ít sự thay đổi trên bất kỳ * nix nào
• đánh bại câu hỏi
• chơi kết thúc tuyệt vời

Sau một vài lần thử, tôi đã tạo ra một biểu đồ trông như thế này: