Tugas

Dengan menggunakan semua jenis parallelisation, tunggu beberapa periode, untuk total waktu tidur setidaknya satu menit (tetapi kurang dari satu setengah menit).

Program / fungsi harus berakhir dalam 10 detik dan mengembalikan (dengan cara apa pun dan dalam format apa pun) dua nilai: total waktu yang telah berlalu, dan total waktu tidur yang dieksekusi. Kedua nilai waktu harus memiliki ketelitian minimal 0,1 detik.

Ini mirip dengan konsep jam kerja : pekerjaan yang memakan waktu 60 jam dapat diselesaikan hanya dalam 6 jam jika 10 pekerja membagi pekerjaan. Di sini kita dapat memiliki 60 detik waktu tidur misalnya dalam 10 utas paralel, sehingga hanya membutuhkan 6 detik untuk seluruh pekerjaan diselesaikan.

Contoh

Program MyProgram membuat 14 utas, setiap utas tertidur selama 5 detik:

MyProgram → [5.016,70.105]

Waktu eksekusi lebih besar dari 5 detik, dan total waktu tidur lebih dari 70 detik karena overhead.

Dyalog APL, 65 27 23 21 byte

(⌈/,+/)⎕TSYNC⎕DL&¨9/7

Yaitu:

      (⌈/,+/)⎕TSYNC⎕DL&¨9/7
7.022 63.162

Penjelasan:

• ⎕DL&¨9/7: spin off 9 utas, masing-masing menunggu selama 7 detik. ⎕DLmengembalikan jumlah aktual waktu yang dihabiskan menunggu, dalam detik, yang akan sama dengan argumennya memberi atau mengambil beberapa milidetik.
• ⎕TSYNC: tunggu semua utas selesai, dan dapatkan hasilnya untuk setiap utas.
• (⌈/,+/): mengembalikan waktu eksekusi terlama dari satu utas tunggal (selama eksekusi semua utas lainnya selesai, jadi ini adalah runtime aktual), diikuti oleh jumlah waktu eksekusi semua utas.

Cobalah online!

Python 2, 172 byte

import threading as H,time as T
m=T.time
z=H.Thread
s=m()
r=[]
def f():n=m();T.sleep(9);f.t+=m()-n
f.t=0
exec"r+=[z(None,f)];r[-1].start();"*8
map(z.join,r)
print m()-s,f.t

Ini membutuhkan OS dengan ketepatan waktu lebih dari 1 detik untuk bekerja dengan baik (dengan kata lain, OS modern). 8 thread dibuat yang masing-masing tidur selama 9 detik, menghasilkan runtime realtime ~ 9 detik, dan runtime paralel ~ 72 detik.

Meskipun dokumentasi resmi mengatakan bahwa Threadkonstruktor harus dipanggil dengan argumen kata kunci, saya tetap berhati-hati dan menggunakan argumen posisi. Argumen pertama ( group) harus None, dan argumen kedua adalah fungsi target.

nneonneo menunjukkan dalam komentar bahwa akses atribut (misalnya f.t) lebih pendek dari akses indeks daftar (misalnya t[0]). Sayangnya, dalam banyak kasus, beberapa byte yang didapat dari melakukan ini akan hilang karena harus membuat objek yang memungkinkan atribut yang ditentukan pengguna dibuat saat runtime. Untungnya, fungsi mendukung atribut yang ditentukan pengguna saat runtime, jadi saya mengeksploitasi ini dengan menghemat waktu total dalam tatribut f.

Cobalah online

Terima kasih kepada DenkerAffe untuk -5 byte dengan exectriknya.

Berkat kundor untuk -7 byte dengan menunjukkan bahwa argumen utasnya tidak perlu.

Berkat nneonneo untuk -7 byte dari peningkatan lain-lain.

Utilitas Bash + GNU, 85

\time -f%e bash -c 'for i in {1..8};{ \time -aoj -f%e sleep 8&};wait'
paste -sd+ j|bc

Memaksa penggunaan timeexecutable alih-alih shell builtin dengan awalan dengan a \.

Tambahkan ke file j, yang harus kosong atau tidak ada di awal.

Pergi - 189 byte

Terima kasih @cat!

package main
import(."fmt";."time");var m,t=60001,make(chan int,m);func main(){s:=Now();for i:=0;i<m;i++{go func(){Sleep(Millisecond);t<-0}()};c:=0;for i:=0;i<m;i++{c++};Print(Since(s),c)}

Output (ms): 160,9939ms, 60001 (160ms untuk menunggu 60,001 detik)

Bash 196 117 114 93 byte

Diperbarui untuk mendukung ketepatan waktu yang lebih baik dengan mengintegrasikan saran dari @manatwork dan @Digital Trauma serta beberapa optimasi ruang lainnya:

d()(date +$1%s.%N;)
b=`d`
for i in {1..8};{ (d -;sleep 8;d +)>>j&}
wait
bc<<<`d`-$b
bc<<<`<j`

Perhatikan bahwa ini mengasumsikan jfile tidak ada di awal.

JavaScript (ES6), 148 byte

with(performance)Promise.all([...Array(9)].map(_=>new Promise(r=>setTimeout(_=>r(t+=now()),7e3,t-=now())),t=0,n=now())).then(_=>alert([now()-n,t]));

Berjanji untuk menunggu 9 kali selama 7 detik untuk total 63 detik (sebenarnya 63.43 ketika saya mencoba), tetapi hanya benar-benar mengambil 7.05 detik waktu nyata ketika saya mencoba.

C, 127 byte (berputar CPU)

Solusi ini memutar CPU alih-alih tidur, dan menghitung waktu menggunakan timesfungsi POSIX (yang mengukur waktu CPU yang dikonsumsi oleh proses induk dan pada semua anak yang menunggu).

Ini memotong 7 proses yang berputar selama 9 detik masing-masing, dan mencetak waktu akhir dalam jam C (pada sebagian besar sistem, 100 tick jam = 1 detik).

t;v[4];main(){fork(fork(fork(t=time(0))));while(time(0)<=t+9);wait(0);wait(0);wait(0)>0&&(times(v),printf("%d,%d",v[0],v[2]));}

Output sampel:

906,6347

artinya 9,06 detik waktu nyata dan 63,47 detik total waktu CPU.

Untuk hasil terbaik, kompilasi dengan -std=c90 -m32(memaksa kode 32-bit pada mesin 64-bit).

PowerShell v4, 144 byte

$d=date;gjb|rjb
1..20|%{sajb{$x=date;sleep 3;((date)-$x).Ticks/1e7}>$null}
while(gjb -s "Running"){}(gjb|rcjb)-join'+'|iex
((date)-$d).Ticks/1e7

Setel $ddengan Get-Date, dan hapus semua riwayat pekerjaan yang ada Get-Job | Remove-Job. Kami kemudian mengulang 1..20|%{...}dan setiap iterasi mengeksekusi Start-Jobmelewati blok skrip {$x=date;sleep 3;((date)-$x).ticks/1e7}untuk pekerjaan (artinya setiap pekerjaan akan mengeksekusi blok skrip itu). Kami menyalurkan output itu ke >$nulluntuk menekan umpan balik (yaitu, nama pekerjaan, status, dll.) Yang dikembalikan.

Blok skrip disetel $xke Get-Date, lalu Start-Sleepuntuk 3detik, lalu mengambil Get-Datebacaan baru , kurangi $x, dapatkan .Ticks, dan 1e7bagi dengan untuk mendapatkan detik (dengan presisi).

Kembali ke utas utama, selama pekerjaan apa pun masih -Status "Running", kami berputar di dalam whilelingkaran kosong . Setelah selesai, kita Get-Jobmenarik objek untuk semua pekerjaan yang ada, menyalurkan Receive-Jobyang akan menarik setara dengan STDOUT (yaitu, apa yang mereka hasilkan), -joinhasilnya bersama-sama +, dan pipa itu ke iex( Invoke-Expressiondan mirip dengan eval). Ini akan menampilkan waktu tidur yang dihasilkan ditambah overhead.

Baris terakhir serupa, yaitu mendapat tanggal baru, mengurangi cap tanggal asli $d, mendapatkan .Ticks, dan membaginya dengan 1e7untuk menghasilkan total waktu eksekusi.

NB

OK, jadi ini sedikit aturan yang membengkok . Rupanya pada eksekusi pertama, PowerShell perlu memuat sekelompok .NET assemblies dari disk untuk berbagai operasi thread karena mereka tidak dimuat dengan profil shell default. Eksekusi berikutnya , karena majelis sudah dalam memori, berfungsi dengan baik. Jika Anda membiarkan jendela shell cukup lama, Anda akan mendapatkan pengumpulan sampah bawaan PowerShell untuk datang dan membongkar semua rakitan, yang menyebabkan eksekusi berikutnya memakan waktu lama karena memuat ulang mereka. Saya tidak yakin dengan cara ini.

Anda dapat melihat ini di waktu eksekusi di bawah berjalan. Saya memulai shell baru, menavigasi ke direktori golf saya, dan mengeksekusi skrip. Run pertama menghebohkan, tetapi yang kedua (dieksekusi segera) bekerja dengan baik. Saya kemudian meninggalkan shell menganggur selama beberapa menit untuk membiarkan pengumpulan sampah datang, dan kemudian menjalankan itu lagi panjang, tetapi berjalan selanjutnya berfungsi dengan baik.

Contoh berjalan

Windows PowerShell
Copyright (C) 2014 Microsoft Corporation. All rights reserved.

PS H:\> c:

PS C:\> cd C:\Tools\Scripts\golfing

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
63.232359
67.8403415

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.0809705
8.8991164

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
62.5791712
67.3228933

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.1303589
8.5939405

PS C:\Tools\Scripts\golfing> .\wait-a-minute.ps1
61.3210352
8.6386886

PS C:\Tools\Scripts\golfing>

Javascript (ES6), 212 203 145 byte

Kode ini menghasilkan 10 gambar dengan interval waktu masing-masing tepat 6 detik, setelah memuat.

Waktu pelaksanaan berjalan sedikit di atasnya (karena overhead).

Kode ini menimpa semua yang ada di dokumen!

P=performance,M=P.now(T=Y=0),document.body.innerHTML='<img src=# onerror=setTimeout(`T+=P.now()-M,--i||alert([P.now()-M,T])`,6e3) >'.repeat(i=10)

Ini mengasumsikan bahwa Anda menggunakan pengkodean byte tunggal untuk backticks, yang diperlukan agar mesin Javascript tidak tersandung.

Sebagai alternatif, jika Anda tidak ingin menunggu selama 6 detik, inilah solusi 1 byte lebih lama yang selesai dalam waktu kurang dari satu detik:

P=performance,M=P.now(T=Y=0),document.body.innerHTML='<img src=# onerror=setTimeout(`T+=P.now()-M,--i||alert([P.now()-M,T])`,600) >'.repeat(i=100)

Perbedaannya adalah bahwa kode ini menunggu 600 ms melintasi 100 gambar. Ini akan memberikan jumlah overhead yang besar.

Versi lama (203 byte):

Kode ini menciptakan 10 iframe dengan interval waktu masing-masing tepat 6 detik, alih-alih membuat 10 gambar.

for(P=performance,M=P.now(T=Y=i=0),D=document,X=_=>{T+=_,--i||alert([P.now()-M,T])};i<10;i++)I=D.createElement`iframe`,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I)

Versi asli (212 byte):

P=performance,M=P.now(T=Y=0),D=document,X=_=>{T+=_,Y++>8&&alert([P.now()-M,T])},[...''+1e9].map(_=>{I=D.createElement`iframe`,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I)})

Ruby, 92

n=->{Time.now}
t=n[]
a=0
(0..9).map{Thread.new{b=n[];sleep 6;a+=n[]-b}}.map &:join
p n[]-t,a

Javascript (ES6), 108 92 byte

Saya membuat jawaban baru karena ini menggunakan pendekatan yang sedikit berbeda.

Ini menghasilkan sejumlah besar setTimeouts, yang hampir semua dieksekusi dengan 4ms di antara mereka.

Setiap interval adalah 610 milidetik, lebih dari total 99 interval.

M=(N=Date.now)(T=Y=0),eval('setTimeout("T+=N()-M,--i||alert([N()-M,T])",610);'.repeat(i=99))

Biasanya berjalan dalam 610ms, dengan total waktu eksekusi sekitar 60,5 detik.

Ini diuji pada Google Chrome versi 51.0.2704.84 m, di windows 8.1 x64.

Versi lama (108 byte):

P=performance,M=P.now(T=Y=0),eval('setTimeout("T+=P.now()-M,--i||alert([P.now()-M,T])",610);'.repeat(i=99))

Scratch - 164 bytes (16 blok)

when gf clicked
set[t v]to[
repeat(9
  create clone of[s v
end
wait until<(t)>[60
say(join(join(t)[ ])(timer
when I start as a clone
wait(8)secs
change[t v]by(timer

Lihat beraksi di sini .

Menggunakan variabel yang disebut 't' dan sprite disebut 's'. Sprite menciptakan klon dari dirinya sendiri, masing-masing menunggu 8 detik, dan menambahkan variabel clocking seluruh waktu tunggu. Pada akhirnya dikatakan total waktu eksekusi dan total waktu tunggu (misalnya, 65.488 8.302).

Clojure, 135 120 111 109 byte

(let[t #(System/nanoTime)s(t)f #(-(t)%)][(apply +(pmap #(let[s(t)](Thread/sleep 7e3)%(f s))(range 9)))(f s)])

Versi terformat dengan variabel bernama:

(let [time #(System/currentTimeMillis)
      start (time)
      fmt #(- (time) %)]
  [(apply +
           (pmap #(let [thread-start (time)]
                   (Thread/sleep 7e3)
                   %
                   (fmt thread-start)) (range 9)))
   (fmt start)])

output (dalam nanodetik):

[62999772966 7001137032]

Format yang diubah. Terima kasih Adm, saya mungkin telah melewatkan spesifikasi format dalam pertanyaan ketika saya membacanya.

Diubah menjadi nanoTime untuk kemampuan bermain golf.

Terima kasih cliffroot, saya benar-benar lupa tentang notasi ilmiah dan tidak percaya saya tidak melihat apply. Saya pikir saya menggunakannya dalam sesuatu yang saya main golf kemarin tetapi tidak pernah diposting. Anda menyelamatkan saya 2 byte.

Rust, 257 , 247 byte

Saya menggunakan waktu yang sama dengan jawaban Python Mego.

Sungguh satu-satunya bit yang sedikit pintar menggunakan ii untuk mendapatkan Durasi 0 detik.

fn main(){let n=std::time::Instant::now;let i=n();let h:Vec<_>=(0..8).map(|_|std::thread::spawn(move||{let i=n();std::thread::sleep_ms(9000);i.elapsed()})).collect();let mut t=i-i;for x in h{t+=x.join().unwrap();}print!("{:?}{:?}",t,i.elapsed());}

Cetakan:

Duration { secs: 71, nanos: 995877193 }Duration { secs: 9, nanos: 774491 }

Tidak Disatukan:

fn main(){
    let n = std::time::Instant::now;
    let i = n();
    let h :Vec<_> =
        (0..8).map(|_|
            std::thread::spawn(
                move||{
                    let i = n();
                    std::thread::sleep_ms(9000);
                    i.elapsed()
                }
            )
        ).collect();
    let mut t=i-i;
    for x in h{
        t+=x.join().unwrap();
    }
    print!("{:?}{:?}",t,i.elapsed());
}

Sunting: baik lama untuk loop sedikit lebih pendek

JavaScript (ES6, menggunakan WebWorkers), 233 215 byte

c=s=0;d=new Date();for(i=14;i-->0;)(new Worker(URL.createObjectURL(new Blob(['a=new Date();setTimeout(()=>postMessage(new Date()-a),5e3)'])))).onmessage=m=>{s+=m.data;if(++c>13)console.log((new Date()-d)/1e3,s/1e3)}

UPD: menggantikan cara pekerja dieksekusi dari string dengan yang lebih kompak dan lintas-browser, dalam aspek kebijakan lintas-asal. Tidak akan berfungsi di Safari, jika masih memiliki webkitURLobjek URL, dan di IE.

Python 2, 130 byte

import thread as H,time as T
m=T.clock;T.z=m()
def f(k):T.sleep(k);T.z+=m()
exec"H.start_new_thread(f,(7,));"*9
f(8);print m(),T.z

Ini adalah turunan dari jawaban Mego, tetapi cukup berbeda karena saya pikir itu harus menjadi jawaban yang terpisah. Ini diuji untuk bekerja pada Windows.

Pada dasarnya, itu memotong 9 utas, yang tidur selama 7 detik sementara orangtua tidur selama 8. Kemudian ia mencetak waktu. Output sampel:

8.00059192923 71.0259046024

Di Windows, time.clockmengukur waktu dinding sejak panggilan pertama.

Perl 6, 72 71 byte

Mungkin ada cara yang lebih pendek untuk melakukan ini

say sum await map {start {sleep 7;now -ENTER now}},^9;say now -INIT now

output ini

63.00660729694
7.0064013

Mathematica, 109 byte

a=AbsoluteTiming;LaunchKernels@7;Plus@@@a@ParallelTable[#&@@a@Pause@9,{7},Method->"EvaluationsPerKernel"->1]&

Fungsi anonim. Memerlukan lisensi dengan 7+ sub-kernel untuk dijalankan. Membutuhkan 9 detik waktu nyata dan 63 detik waktu kernel, tidak memperhitungkan overhead. Pastikan untuk hanya menjalankan pernyataan sebelumnya sekali (sehingga tidak mencoba meluncurkan kembali kernel). Pengujian:

In[1]:= a=AbsoluteTiming;LaunchKernels@7;func=Plus@@@a@ParallelTable[#&@@a@Pause
@9,{7},Method->"EvaluationsPerKernel"->1]&;

In[2]:= func[]

Out[2]= {9.01498, 63.0068}

In[3]:= func[]

Out[3]= {9.01167, 63.0047}

In[4]:= func[]

Out[4]= {9.00587, 63.0051}

Javascript (ES6), 105 byte

((t,c,d)=>{i=t();while(c--)setTimeout((c,s)=>{d+=t()-s;if(!c)alert([t()-i,d])},8e3,c,t())})(Date.now,8,0)

Versi terbaru: 106 byte Dipinjam dari @Ismael Miguel karena ia punya ide bagus untuk menurunkan waktu tidur dan meningkatkan interval.

((t,c,d)=>{i=t();while(c--)setTimeout((c,s)=>{d+=t()-s;if(!c)alert([t()-i,d])},610,c,t())})(Date.now,99,0)

Javascript Ungolfed, 167 byte

(function(t, c, d){
	i = t();
	while(c--){
		setTimeout(function(c, s){
			d += t() - s;
			if (!c) alert([t() - i, d])
		}, 8e3, c, t())
	}
})(Date.now, 8, 0)

Java, 358 343 337 316 313 byte

import static java.lang.System.*;class t extends Thread{public void run(){long s=nanoTime();try{sleep(999);}catch(Exception e){}t+=nanoTime()-s;}static long t,i,x;public static void main(String[]a)throws Exception{x=nanoTime();for(;++i<99;)new t().start();sleep(9000);out.println((nanoTime()-x)/1e9+" "+t/1e9);}}

dan ungolfed

import static java.lang.System.*;

class t extends Thread {
    public void run() {
        long s = nanoTime();
        try {
            sleep(999);
        } catch (Exception e) {
        }
        t += nanoTime() - s;
    }

    static long t,i,x;

    public static void main(String[] a) throws Exception {
        x = nanoTime();
        for (; ++i < 99;)
            new t().start();
        sleep(9000);
        out.println((nanoTime() - x) / 1e9 + " " + t / 1e9);
    }
}

tolong jangan mencobanya di rumah, karena solusi ini tidak aman untuk thread.

Sunting:

Saya mengambil saran @A Boschman dan @ Adám, dan sekarang program saya membutuhkan waktu kurang dari 10 detik untuk berjalan, dan lebih pendek 15 byte.

C (dengan pthreads), 339 336 335 byte

#include<stdio.h>
#include<sys/time.h>
#include<pthread.h>
#define d double
d s=0;int i;pthread_t p[14];d t(){struct timeval a;gettimeofday(&a,NULL);return a.tv_sec+a.tv_usec/1e6;}
h(){d b=t();sleep(5);s+=t()-b;}
main(){d g=t();for(i=14;i-->0;)pthread_create(&p[i],0,&h,0);for(i=14;i-->0;)pthread_join(p[i],0);printf("%f %f",t()-g,s);}

C90 (OpenMP), 131 Bytes (+ 17 untuk variabel env) = 148 Bytes

#include <omp.h>
#define o omp_get_wtime()
n[4];main(t){t=o;
#pragma omp parallel
while(o-9<t);times(n);printf("%d,%f",n[0],o-t);}

Contoh Output:

7091,9.000014

Catatan:

7091 dalam siklus (100 / detik), sehingga program berjalan selama 70 detik

Bisa jadi jauh lebih pendek jika saya menemukan cara untuk mendapatkan timer untuk bekerja selain omp_get_wtime () karena saya bisa menghapus pernyataan include juga.

Jalankan dengan OMP_NUM_THREADS = 9

Common Lisp (SBCL) 166 byte:

(do((m #1=(get-internal-real-time))(o(list 0)))((>(car o)60000)`(,(car o),(- #1#m)))(sb-thread:make-thread(lambda(&aux(s #1#))(sleep 1)(atomic-incf(car o)(- #1#s)))))

Ini hanya memunculkan thread yang tidur dan kemudian secara atom meningkatkan waktu yang diperlukan, dengan loop luar yang berputar menunggu total waktu menjadi lebih dari 60000 kutu (yaitu 60 detik pada sbcl). Penghitung disimpan dalam daftar karena keterbatasan pada jenis tempat yang dapat dimodifikasi oleh atom-incf. Ini mungkin kehabisan ruang sebelum berhenti pada mesin yang lebih cepat.

Tidak Disatukan:

(do ((outer-start (get-internal-real-time))
       (total-inner (list 0)))
      ((> (car total-inner) 60000)
       `(,(car total-inner)
      ,(- (get-internal-real-time) outer-start)))
    (sb-thread:make-thread
     (lambda (&aux(start (get-internal-real-time)))
       (sleep 1)
       (atomic-incf (car total-inner) (- (get-internal-real-time) start)))))

Perl, 101 byte

use Time::HiRes<time sleep>;pipe*1=\time,0;
print time-$1,eval<1>if open-print{fork&fork&fork}-sleep 9

Garpu 7 proses anak, masing-masing menunggu 9 detik.

Output sampel:

perl wait-one-minute.pl
9.00925707817078-63.001741

Groovy, 158 143 karakter

d={new Date().getTime()}
s=d(j=0)
8.times{Thread.start{b=d(m=1000)
sleep 8*m
synchronized(j){j+=d()-b}}}addShutdownHook{print([(d()-s)/m,j/m])}

Contoh dijalankan:

bash-4.3$ groovy wait1minute.groovy
[8.031, 64.055]

Elixir, 168 byte

import Task;import Enum;IO.puts elem(:timer.tc(fn->IO.puts(map(map(1..16,fn _->async(fn->:timer.tc(fn->:timer.sleep(4000)end)end)end),&(elem(await(&1),0)))|>sum)end),0)

Contoh dijalankan:

$ elixir thing.exs
64012846
4007547

Outputnya adalah total waktu yang ditunggu diikuti oleh waktu program berjalan, dalam mikrodetik.

Program ini menghasilkan 14 Taskdetik, dan menunggu masing-masing dengan memetakannya, dan kemudian menemukan jumlah waktu yang telah berlalu. Ini menggunakan Erlang timeruntuk mengukur waktu.

Haskell, 278 271 262 246 byte

import Control.Concurrent.Chan
import Data.Time
import GHC.Conc
t=getCurrentTime
b!a=b=<<flip diffUTCTime<$>t<*>(a>>t)
w=threadDelay$5^10
0#_=t
i#a=a>>(i-1)#a
main=print!do r<-newChan;9#(forkIO$writeChan r!w);getChanContents r>>=print.sum.take 9

!mengukur waktu yang diambil oleh tindakan a(argumen kedua) dan berlaku b(argumen pertama) untuk hasilnya.

w adalah fungsi tidur.

maindiukur sendiri, dan hasilnya dicetak ( print!...).

#adalah replicateM, mengulangi tindakan yang diberikan sebanyak N kali (dan kembali tkarena bermain golf).

Di dalam bagian yang diukur, 9 utas ( replicate 9 $ forkIO ...) tidur selama 5^10milidetik (9,765625 detik) dan posting hasilnya ( writeChan) ke pipa yang dibuat oleh utas utama ( newChan), yang merangkum 9 hasil dan mencetak total ( getChanContents >>= print . sum . take 9).

Keluaran:

87.938546708s
9.772032144s

Python 2, 132 byte

Menggunakan kumpulan proses untuk menghasilkan 9 proses dan biarkan masing-masing tidur selama 7 detik.

import time as t,multiprocessing as m
def f(x):d=s();t.sleep(x);return s()-d
s=t.time
a=s()
print sum(m.Pool(9).map(f,[7]*9)),s()-a

Mencetak total akumulasi sleeptime pertama, kemudian runtime yang sebenarnya:

$ python test.py
63.0631158352 7.04391384125

Ruby (dengan parallelpermata), 123 116 byte

require'parallel'
n=->{Time.now}
t=n[]
q=0
Parallel.each(1..10,:in_threads=>10){z=n[];sleep 6;q+=n[]-z}
puts n[]-t,q

Sunting: Menambahkan referensi "Time.now" dari jawaban Ruby oleh histocrat.

Matlab, 75 byte

tic;parpool(9);b=1:9;parfor q=b
a=tic;pause(7);b(q)=toc(a);end
[sum(b);toc]

Penjelasan cepat: parformembuat loop paralel, didistribusikan di seluruh kumpulan pekerja. ticdan tocmengukur waktu yang telah berlalu (dan menurut saya salah satu fungsi terbaik yang disebutkan di MATLAB). Baris terakhir (array dengan total waktu tidur dan waktu sebenarnya berlalu) dikeluarkan karena tidak diakhiri dengan tanda titik koma.

Namun perlu dicatat bahwa ini menciptakan 9 proses MATLAB lengkap. Kemungkinannya adalah bahwa program khusus ini tidak akan selesai dalam waktu 10 detik yang diberikan pada mesin Anda. Namun, saya pikir dengan instalasi MATLAB yang tidak memiliki kotak alat kecuali kotak alat Komputasi Paralel yang diinstal - diinstal pada sistem high-end dengan SSD - mungkin hanya dapat selesai dalam 10 detik. Jika diperlukan, Anda dapat mengubah parameter agar proses tidur lebih sedikit.