Zadanie

Korzystając z dowolnego rodzaju paralelizacji, odczekaj kilka okresów, aby całkowity czas snu wynosił co najmniej minutę (ale mniej niż półtorej minuty).

Program / funkcja musi zakończyć się w ciągu 10 sekund i zwrócić (w jakikolwiek sposób iw dowolnym formacie) dwie wartości: całkowity czas, który upłynął, i całkowity czas wykonania snu. Obie wartości czasu muszą mieć dokładność co najmniej 0,1 sekundy.

Jest to podobne do pojęcia roboczogodzin : zadanie, które zajmuje 60 godzin, można wykonać w zaledwie 6 godzin, jeśli 10 pracowników dzieli zadanie. Tutaj możemy mieć 60 sekund czasu snu, np. W 10 równoległych wątkach, co wymaga jedynie 6 sekund na wykonanie całego zadania.

Przykład

Program MyProgram tworzy 14 wątków, każdy wątek śpi przez 5 sekund:

MyProgram → [5.016,70.105]

Czas wykonania jest dłuższy niż 5 sekund, a całkowity czas snu jest dłuższy niż 70 sekund z powodu obciążenia.

Dyalog APL, 65 27 23 21 bajtów

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

To znaczy:

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

Wyjaśnienie:

• ⎕DL&¨9/7: odkręć 9 wątków, z których każdy czeka 7 sekund. ⎕DLzwraca rzeczywisty czas oczekiwania w sekundach, który będzie taki sam, jak argument podany lub potrwa kilka milisekund.
• ⎕TSYNC: poczekaj na zakończenie wszystkich wątków i uzyskaj wynik dla każdego wątku.
• (⌈/,+/): zwraca najdłuższy czas wykonania pojedynczego wątku (podczas wykonywania którego wszystkie pozostałe wątki zostały zakończone, więc jest to rzeczywisty czas działania), a następnie sumę czasu wykonania wszystkich wątków.

Wypróbuj online!

Python 2, 172 bajty

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

Wymaga to, aby system operacyjny z dokładnością czasową większą niż 1 sekunda działał poprawnie (innymi słowy, każdy nowoczesny system operacyjny). Utworzono 8 wątków, które śpią przez 9 sekund, co daje czas działania w czasie rzeczywistym ~ 9 sekund i równoległy czas działania ~ 72 sekund.

Chociaż oficjalna dokumentacja mówi, że Threadkonstruktor powinien być wywoływany z argumentami słów kluczowych, rzucam ostrożność na wiatr i i tak używam argumentów pozycyjnych. Pierwszym argumentem ( group) musi być None, a drugim argumentem jest funkcja docelowa.

nneonneo wskazał w komentarzach, że dostęp do atrybutu (np. f.t) jest krótszy niż dostęp do indeksu listy (np t[0].). Niestety w większości przypadków kilka bajtów uzyskanych w ten sposób zostałoby utraconych przez konieczność utworzenia obiektu, który umożliwi tworzenie atrybutów zdefiniowanych przez użytkownika w czasie wykonywania. Na szczęście funkcje obsługują atrybuty zdefiniowane przez użytkownika w czasie wykonywania, więc wykorzystuję to, oszczędzając całkowity czas w tatrybucie f.

Wypróbuj online

Dzięki DenkerAffe za -5 bajtów z exectrikiem.

Dzięki kundor dla -7 bajtów, wskazując, że argument wątku jest niepotrzebny.

Dzięki nneonneo za -7 bajtów z różnych ulepszeń.

Narzędzia Bash + GNU, 85

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

Wymusza użycie timepliku wykonywalnego zamiast wbudowanej powłoki przez przedrostek z \.

Dołącza do pliku j, który musi być pusty lub nieistniejący na początku.

Idź - 189 bajtów

Dzięki @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)}

Wyjścia (ms): 160,9939 ms , 60001 (160 ms, aby czekać 60,001 sekund)

Bash 196 117 114 93 bajtów

Zaktualizowano, aby obsługiwał lepszą precyzję czasu, integrując sugestie @manatwork i @Digital Trauma, a także kilka innych optymalizacji przestrzeni:

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

Zauważ, że zakłada to, że jplik jest nieobecny na początku.

JavaScript (ES6), 148 bajtów

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

Obiecuje czekać 9 razy przez 7 sekund w sumie 63 sekundy (faktycznie 63,43, kiedy próbuję), ale tak naprawdę zajmuje tylko 7,05 sekundy czasu rzeczywistego, gdy próbuję.

C, 127 bajtów (obraca procesor)

To rozwiązanie obraca procesor zamiast spać i odlicza czas za pomocą timesfunkcji POSIX (która mierzy czas procesora zużywany przez proces nadrzędny i wszystkie oczekiwane dzieci).

Odrzuca 7 procesów, które wirują przez 9 sekund na sekundę, i drukuje czasy końcowe w zegarach C (w większości systemów 100 tyknięć zegara = 1 sekunda).

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

Przykładowe dane wyjściowe:

906,6347

co oznacza 9,06 sekund czasu rzeczywistego i 63,47 sekundy całkowitego czasu procesora.

Aby uzyskać najlepsze wyniki, skompiluj za pomocą -std=c90 -m32(wymuś kod 32-bitowy na komputerze 64-bitowym).

PowerShell v4, 144 bajty

$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

Zestawy są $drówne Get-Datei usuwa wszystkie istniejące historie zadań Get-Job | Remove-Job. Następnie zapętlamy 1..20|%{...}i każda iteracja wykonuje Start-Jobprzekazanie bloku skryptu {$x=date;sleep 3;((date)-$x).ticks/1e7}dla zadania (co oznacza, że ​​każde zadanie wykona ten blok skryptu). Przesyłamy dane wyjściowe do >$null, aby ukryć informacje zwrotne (tj. Nazwę zadania, status itp.), Które zostaną zwrócone.

Blok skryptu ustawia się $xna Get-Date, potem Start-Sleepna 3sekundy, a następnie bierze nowy Get-Dateodczyt, odejmuje $x, pobiera .Ticksi dzieli przez, 1e7aby uzyskać sekundy (z precyzją).

Z powrotem w głównym wątku, tak długo, jak każda praca jest nadal -Status "Running", obracamy się w pustej whilepętli. Kiedy to zrobimy, będziemy Get-Jobpobierać obiekty dla wszystkich istniejących zadań, potokować te, do Receive-Jobktórych pobiorą ekwiwalent STDOUT (tj. To, co wyprowadzają), -joinwyniki wraz z +, i potokować do iex( Invoke-Expressioni podobnie do eval). Spowoduje to wygenerowanie wynikowego czasu uśpienia plus narzutu.

Ostatnia linia jest podobna, ponieważ pobiera nową datę, odejmuje oryginalny znacznik daty $d, pobiera .Ticksi dzieli przez, 1e7aby wyświetlić całkowity czas wykonania.

NB

OK, więc to trochę zgubne zasady. Najwyraźniej przy pierwszym uruchomieniu PowerShell musi załadować kilka zestawów .NET z dysku dla różnych operacji wątków, ponieważ nie są one ładowane z domyślnym profilem powłoki. Kolejne wykonania, ponieważ zestawy są już w pamięci, działają dobrze. Jeśli pozostawisz okno powłoki wystarczająco długo bezczynne, dostaniesz wbudowane zbieranie śmieci w PowerShell i usuniesz wszystkie te zespoły, co spowoduje, że następne wykonanie zajmie dużo czasu, gdy zostaną ponownie załadowane. Nie jestem pewien, jak to obejść.

Możesz to zobaczyć w czasach wykonania w poniższych uruchomieniach. Uruchomiłem nową powłokę, przeszedłem do katalogu golfa i wykonałem skrypt. Pierwszy bieg był przerażający, ale drugi (wykonany natychmiast) działał dobrze. Następnie pozostawiłem muszlę bezczynną na kilka minut, aby umożliwić przechodzenie do śmiecia, a potem ta kolejność jest znowu długa, ale kolejne serie znów działają dobrze.

Przykład działa

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 bajtów

Ten kod po załadowaniu tworzy 10 obrazów w odstępie dokładnie 6 sekund.

Czas wykonania nieznacznie przekracza go (z powodu obciążenia).

Ten kod zastępuje wszystko w dokumencie!

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)

Zakłada się, że używasz kodowania jednobajtowego dla backticks, co jest wymagane, aby silnik Javascript nie zadziałał.

Alternatywnie, jeśli nie chcesz spędzać 6 sekund na czekaniu, oto 1-bajtowe rozwiązanie, które kończy się w mniej niż sekundę:

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)

Różnica polega na tym, że ten kod czeka 600 ms na 100 obrazów. To da ogromną kwotę narzutu.

Stara wersja (203 bajtów):

Ten kod tworzy 10 ramek iframe z odstępem dokładnie 6 sekund każdy, zamiast tworzyć 10 obrazów.

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)

Wersja oryginalna (212 bajtów):

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 bajty

Robię nową odpowiedź, ponieważ używa nieco innego podejścia.

Generuje ogromną liczbę setTimeouts, które prawie wszystkie są wykonywane z odstępem 4 ms.

Każdy interwał trwa 610 milisekund, w sumie 99 interwałów.

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

Zwykle działa w ciągu 610 ms, a całkowity czas wykonania wynosi około 60,5 sekundy.

Zostało to przetestowane na Google Chrome w wersji 51.0.2704.84 m, na Windows 8.1 x64.

Stara wersja (108 bajtów):

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 bajty (16 bloków)

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

Zobacz to w akcji tutaj .

Używa zmiennej o nazwie „t” i duszka o nazwie „s”. Duszek tworzy własne klony, z których każdy czeka 8 sekund, i zwiększa zmienną taktowaną przez cały czas oczekiwania. Na końcu podaje całkowity czas wykonania i całkowity czas oczekiwania (na przykład 65.488 8.302).

Clojure, 135 120 111 109 bajtów

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

Wersja sformatowana z nazwanymi zmiennymi:

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

wyjście (w nanosekundach):

[62999772966 7001137032]

Zmieniony format. Dzięki Adám, mogłem przeoczyć specyfikację formatu w pytaniu, gdy ją czytam.

Zmieniono na nanoTime dla umiejętności gry w golfa.

Dzięki Cliffroot, zupełnie zapomniałem o notacji naukowej i nie mogę uwierzyć, że nie widziałem apply. Myślę, że użyłem tego w czymś, co grałem wczoraj w golfa, ale nigdy nie opublikowałem. Zapisałeś mi 2 bajty.

Rdza, 257 , 247 bajtów

Używam tych samych czasów, co odpowiedź Mego na Python.

Naprawdę jedynym nieco sprytnym bitem jest użycie ii, aby uzyskać czas trwania 0 sekund.

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

Wydruki:

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

Nie golfowany:

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

Edycja: dobra stara dla pętli jest nieco krótsza

JavaScript (ES6, przy użyciu WebWorkers), 233 215 bajtów

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: zastąpiono sposób, w jaki pracownik jest wykonywany z ciągu, na bardziej zwarty i przeglądarkowy, w aspekcie zasad dotyczących różnych źródeł. Nie będzie działać w przeglądarce Safari, jeśli nadal ma webkitURLobiekt zamiast URLw przeglądarce IE.

Python 2, 130 bajtów

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

To jest pochodna odpowiedzi Mego, ale wystarczająco różni się od tego, że myślałem, że powinna to być osobna odpowiedź. Jest testowany do pracy w systemie Windows.

Zasadniczo usuwa 9 wątków, które śpią przez 7 sekund, podczas gdy rodzic śpi przez 8 lat. Następnie drukuje czasy. Przykładowe dane wyjściowe:

8.00059192923 71.0259046024

W systemie Windows time.clockmierzy czas na ścianie od pierwszego połączenia.

Perl 6, 72 71 bajtów

Może to być krótszy sposób

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

to wychodzi

63.00660729694
7.0064013

Mathematica, 109 bajtów

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

Funkcja anonimowa. Do uruchomienia wymagana jest licencja z sub-jądrem 7+. Zajmuje 9 sekund w czasie rzeczywistym i 63 sekundy czasu jądra, nie uwzględniając kosztów ogólnych. Pamiętaj, aby uruchomić poprzednie instrukcje tylko raz (aby nie próbowało ponownie uruchamiać jądra). Testowanie:

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 bajtów

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

Zaktualizowana wersja: 106 bajtów Pożyczono od @ Ismaela Miguela, ponieważ miał świetny pomysł, aby skrócić czas snu i wydłużyć interwały.

((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 bajtów

(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 bajtów

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

i nie golfił

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

nie próbuj tego w domu, ponieważ to rozwiązanie nie jest bezpieczne dla wątków.

Edytować:

Wziąłem sugestie @A Boschmana i @ Adáma, a teraz mój program wymaga mniej niż 10 sekund na uruchomienie, a jego rozmiar jest krótszy o 15 bajtów.

C (z pthreads), 339 336 335 bajtów

#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 bajtów (+ 17 dla zmiennej env) = 148 bajtów

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

Przykładowe dane wyjściowe:

7091,9.000014

Uwagi:

7091 jest w cyklach (100 / s), więc program działał przez 70 sekund

Mógłbym być znacznie krótszy, gdybym wymyślił sposób na uruchomienie timera inny niż omp_get_wtime (), ponieważ wtedy mógłbym również usunąć instrukcję include.

Uruchom z OMP_NUM_THREADS = 9

Wspólne Lisp (SBCL) 166 bajtów:

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

Powoduje to po prostu odrodzenie wątków, które śpią, a następnie atomowy przyrost czasu. Pętla zewnętrzna obraca się, czekając, aż całkowity czas wyniesie ponad 60000 tyknięć (tj. 60 s na sbcl). Licznik jest przechowywany na liście z powodu ograniczeń typów miejsc, w których atomic-incf może modyfikować. Może to zabraknąć miejsca przed zakończeniem pracy na szybszych komputerach.

Nie golfowany:

(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 bajtów

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

Rozwidla 7 procesów potomnych, z których każdy czeka 9 sekund.

Przykładowe dane wyjściowe:

perl wait-one-minute.pl
9.00925707817078-63.001741

Groovy, 158 143 znaków

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

Przykładowy przebieg:

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

Eliksir, 168 bajtów

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)

Przykładowy przebieg:

$ elixir thing.exs
64012846
4007547

Dane wyjściowe to całkowity czas oczekiwania, a następnie czas działania programu, w mikrosekundach.

Program odradza się przez 14 sekund Taski czeka na każdego z nich, odwzorowując je, a następnie znajduje sumę upływającego czasu. Wykorzystuje Erlanga timerdo pomiaru czasu.

Haskell, 278 271 262 246 bajtów

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

!mierzy czas działania a(drugi argument) i stosuje b(pierwszy argument) do wyniku.

w jest funkcją spania.

mainjest mierzony sam, a wynik drukowany ( print!...).

#to replicateMpowtórzenie podanej akcji N razy (i powrót z tpowodu gry w golfa).

Wewnątrz mierzonej części 9 wątków ( replicate 9 $ forkIO ...) śpi przez 5^10milisekundy (9,765625 sekund) i umieszcza wynik ( writeChan) na rurze utworzonej przez główny wątek ( newChan), który sumuje 9 wyników i drukuje sumę ( getChanContents >>= print . sum . take 9).

Wynik:

87.938546708s
9.772032144s

Python 2, 132 bajty

Korzysta z puli procesów, aby spawnować 9 procesów i pozwolić każdemu z nich spać przez 7 sekund.

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

Najpierw drukuje całkowity czas snu, a następnie rzeczywisty czas działania:

$ python test.py
63.0631158352 7.04391384125

Rubin (z parallelklejnotem), 123 116 bajtów

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

Edycja: Dodano odniesienie „Time.now” z odpowiedzi Ruby autorstwa histocrata.

Matlab, 75 bajtów

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

Szybkie wyjaśnienie: parfortworzy równoległą pętlę for, rozmieszczoną w puli pracowników. tici tocmierz upływ czasu (i moim zdaniem są jedną z najlepiej nazwanych funkcji w MATLAB). Ostatni wiersz (tablica z całkowitym czasem spania i upływem czasu rzeczywistego) jest wyprowadzany, ponieważ nie jest zakończony średnikiem.

Zauważ jednak, że tworzy to aż 9 pełnoprawnych procesów MATLAB. Są szanse, że ten konkretny program nie zakończy się w ciągu 10 sekund na twoim komputerze. Myślę jednak, że w przypadku instalacji MATLAB, która nie ma żadnych zestawów narzędzi, z wyjątkiem zestawu narzędzi Parallel Computing - zainstalowanego w wysokiej klasy systemie z dyskiem SSD - może zakończyć się w ciągu 10 sekund. W razie potrzeby możesz dostosować parametry, aby mniej procesów śpiło więcej.