Görev

Herhangi bir paralelleştirme türünü kullanarak, en az bir dakika (ancak bir buçuk dakikadan az) toplam uyku süresi için birden çok süre bekleyin.

Program / işlev 10 saniye içinde sonlandırılmalı ve (herhangi bir şekilde ve herhangi bir biçimde) iki değer döndürmelidir: toplam geçen süre ve toplam yürütülen uyku süresi. Her iki zaman değerinin en az 0,1 saniye hassasiyete sahip olması gerekir.

Bu, mesai saatleri kavramına benzer : 10 işçi işi bölerse 60 saat süren bir iş ancak 6 saatte tamamlanabilir. Burada 60 saniyelik bir uyku süresine sahip olabiliriz, örneğin 10 paralel ipliğin içinde, böylece tüm işin tamamlanması için sadece 6 saniyenizi gerektirir.

Örnek

MyProgram programı 14 iş parçacığı yaratıyor, her iş parçacığı 5 saniye uyuyor:

MyProgram → [5.016,70.105]

Uygulama süresi 5 saniyeden fazladır ve toplam uyku süresi, ek yük nedeniyle 70 saniyeden fazladır.

Dyalog APL, 65 27 23 21 bayt

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

yani:

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

Açıklama:

• ⎕DL&¨9/7: her biri 7 saniye bekleyecek olan 9 ipliği döndürerek çıkarın. ⎕DLsaniyeler içinde bekleyerek geçirilen gerçek süreyi döndürür; bu, argümanı vermek veya birkaç milisaniye almakla aynı olacaktır.
• ⎕TSYNC: tüm iş parçacıklarının tamamlanmasını bekleyin ve her iş parçacığının sonucunu alın.
• (⌈/,+/): tek bir dişlinin en uzun yürütme zamanını (diğer tüm iş parçacığının bitiminde, yani bu gerçek çalışma zamanıdır) ve ardından tüm dişlilerin yürütme zamanının toplamını döndür.

Çevrimiçi deneyin!

Python 2, 172 bayt

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

Bu, düzgün çalışması için zaman hassasiyetinde 1 saniyeden daha uzun bir işletim sistemi gerektirir (başka bir deyişle, herhangi bir modern işletim sistemi). Her biri 9 saniye uyuyan 8 iplik oluşturulur, bu da ~ 9 saniye gerçek zamanlı çalışma süresine ve ~ 72 saniye paralel çalışma süresine neden olur.

Gerçi resmi belgeler söylüyor Threadyapıcı kelime argümanlarla çağrılmalıdır, ben Rüzgar dikkatli atmak ve yine pozisyonel argümanları kullanırlar. İlk argüman ( group) olmalı Noneve ikinci argüman hedef fonksiyondur.

nneonneo, yorumlarda erişim özelliğinin (örn. f.t) liste dizin erişiminden (örn t[0]. ) daha kısa olduğunu belirtti . Ne yazık ki, çoğu durumda, bunu yapmaktan kazanılan birkaç bayt, çalışma zamanında kullanıcı tanımlı özniteliklerin oluşturulmasına izin veren bir nesne yaratmaya ihtiyaç duyularak kaybolur. Neyse ki, işlevler çalışma zamanında kullanıcı tanımlı öznitelikleri destekler, bu nedenle toplam süreyi töznitelikte kaydederek bu durumdan faydalanırım f.

Çevrimiçi deneyin

Hile ile -5 bayt için DenkerAffe için teşekkürler exec.

-7 bayt için kundor sayesinde thread argümanının gereksiz olduğuna dikkat çekerek.

Çeşitli iyileştirmelerden -7 baytlık nneonneo'ya teşekkürler.

Bash + GNU yardımcı programları, 85

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

A timeile önek ekleyerek kabuk yerleşimi yerine çalıştırılabilir kullanımını zorlar \.

jBaşlangıçta boş veya bulunmaması gereken bir dosyaya eklenir .

Git - 189 bayt

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

Çıktılar (ms): 160.9939ms, 60001 (60.001 saniye beklemek için 160ms)

Bash 196 117 114 93 bayt

@Manatwork ve @Digital Trauma'nın önerilerini ve birkaç diğer alan optimizasyonunu entegre ederek daha iyi zaman hassasiyetini desteklemek için güncellendi:

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

Bunun jbaşında dosyanın bulunmadığını varsaydığını unutmayın .

JavaScript (ES6), 148 bayt

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

Toplam 63 saniye boyunca 7 saniye boyunca 9 kez bekleyeceğine söz veriyor (denememde aslında 63.43), ancak denediğimde sadece 7.05 saniye sürüyor.

C, 127 bayt (CPU döndürür)

Bu çözüm CPU'yu uyumak yerine döndürür ve timesPOSIX işlevini kullanarak zaman sayar (ana işlem tarafından tüketilen CPU süresini ölçer ve tüm bekletilen çocuklar için).

Her biri 9 saniye boyunca dönen 7 işlemi iptal eder ve son saatleri C saatlerinde yazdırır (çoğu sistemde, 100 saat geçmesi = 1 saniye).

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

Örnek çıktı:

906,6347

9.06 saniye gerçek zamanlı ve 63.47 saniye toplam CPU anlamına gelir.

En iyi sonuçlar için derleme yapın -std=c90 -m32(64 bit makinede 32 bit kod zorla).

PowerShell v4, 144 bayt

$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

Kümeler $diçin eşit Get-Dateve birlikte varolan herhangi bir iş geçmişlerini temizler Get-Job | Remove-Job. Daha sonra döngü yapıyoruz 1..20|%{...}ve her yineleme iş için Start-Jobkomut dosyası bloğunu geçerek yürütüyoruz {$x=date;sleep 3;((date)-$x).ticks/1e7}(yani, her iş bu komut dosyası bloğunu yürütecek). >$nullİade edilen geri bildirimi (örneğin, iş adı, durumu vb.) Bastırmak için bu çıktının boru hattını yerleştiriyoruz.

Komut dosyası bloğu setleri $xiçin Get-Date, o Start-Sleepiçin 3saniye sonra yeni sürer Get-Date, okuma çıkarır $x, alır .Ticksve böler 1e7(hassasiyetle) saniye alır.

Ana iş parçacığına geri dönersek, herhangi bir iş hala -Status olduğu sürece "Running"boş bir whiledöngü içinde döneriz . Bu işlem tamamlandıktan sonra, biz Get-Job, mevcut tüm işler için nesneleri yukarı çekmek için boru olanlara Receive-Jobhangi STDOUT eşdeğer (yani ne çıktı) yukarı çeker -joinbirlikte sonuçları +ve boru bu kadar iex( Invoke-Expressionve benzeri eval). Bu, ortaya çıkan uyku süresini artı ek yükü verecektir.

Son satır benzerdir, yeni bir tarih alırsa, orijinal tarih damgasını çıkarır $d, alır .Ticksve 1e7toplam yürütme süresinin çıktısını almak üzere böler .

NB

Tamam, bu kuralların biraz gerginliği . Görünüşe göre, ilk çalıştırmada, PowerShell, varsayılan kabuk profiliyle yüklenmediğinden, çeşitli iş parçacığı işlemleri için diskten bir sürü .NET derlemesi yüklemesi gerekiyor. Daha sonraki işlemler , derlemeler zaten bellekte olduğundan, iyi çalışıyor. Kabuk penceresini yeterince boşta bırakırsanız, PowerShell'in yerleşik çöp koleksiyonunun yanına gelmesini ve tüm bu montajları boşaltmasını sağlayarak bir sonraki uygulamanın yeniden yüklenirken uzun zaman almasına neden olursunuz . Bunun bir yolundan emin değilim.

Bunu aşağıdaki çalışmalarda yürütme sürelerinde görebilirsiniz. Yeni bir kabuk başlattım, golf dizinime gittim ve senaryoyu yürüttüm. İlk deneme korkunçtu, ikincisi (hemen idam edildi) iyi çalıştı. Daha sonra çöp toplama işleminin gerçekleşmesini sağlamak için kabuğunu birkaç dakika boşta bıraktım ve sonra bu işlem tekrar uzun sürdü, ancak sonraki işlemler yine iyi sonuç veriyor.

Örnek çalıştırmalar

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 bayt

Bu kod, yüklendikten sonra her biri tam 6 saniyelik bir zaman aralığıyla 10 görüntü oluşturur.

Yürütme süresi, üstünde ( biraz fazla olduğundan) küçük bir parça gider .

Bu kod belgedeki her şeyin üzerine yazar!

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)

Bu, Javascript motorunun açmaması gereken geri tepmeler için tek baytlık bir kodlama kullandığınızı varsayar.

Alternatif olarak, 6 saniye beklemek istemiyorsanız, işte bir saniyeden daha kısa sürede bitecek 1 bayt daha uzun bir çözüm:

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)

Aradaki fark, bu kodun 100 görüntüde 600ms beklemesidir. Bu büyük bir ek yük getirecek.

Eski sürüm (203 bayt):

Bu kod, 10 görüntü oluşturmak yerine, her biri tam olarak 6 saniyelik bir zaman aralığıyla 10 iframe oluşturur.

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)

Orijinal versiyon (212 bayt):

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 bayt

Bu biraz farklı bir yaklaşım kullandığı için yeni bir cevap veriyorum.

setTimeoutNeredeyse tümü aralarında 4 ms ile yürütülen büyük miktarda s üretir .

Her aralık, toplam 99 aralık boyunca 610 milisaniyedir.

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

Genellikle yaklaşık 60.5 saniyelik toplam yürütme süresi için 610ms içinde çalışır.

Bu, Google Chrome sürüm 51.0.2704.84 m’de, Windows 8.1 x64’te test edildi.

Eski versiyon (108 bayt):

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

Karalama - 164 bayt (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

Burada çalışırken görün .

'T' denilen bir değişken ve 's' denilen bir sprite kullanır. Sprite, her biri 8 saniye bekleyen, kendi klonlarını yaratır ve tüm bekleme süresini saran bir değişkeni arttırır. Sonunda toplam yürütme süresi ve toplam bekleme süresi (örneğin 65.488 8.302) yazıyor .

Clojure, 135 120 111 109 bayt

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

Adlandırılmış değişkenlerle biçimlendirilmiş sürüm:

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

çıktı (nanosaniye cinsinden):

[62999772966 7001137032]

Değişen format Teşekkürler Adám, okuduğumda söz konusu format formatlama özelliğini kaçırmış olabilirim.

Golf yetenekleri için nanoTime olarak değiştirildi.

Teşekkürler cliffroot, bilimsel gösterimi tamamen unuttum ve görmediğime inanamıyorum apply. Sanırım bunu dün golf oynadığım ama hiç yayınlamadığım bir şeyde kullandım. Beni 2 bayt kurtardın.

Pas, 257 , 247 bayt

Mego'nun Python yanıtıyla aynı zamanlarda kullanıyorum.

Gerçekten, sadece biraz zekice, 0 saniyelik bir Süreyi elde etmek için ii kullanıyor.

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

Baskılar:

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

Ungolfed:

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

Düzenleme: döngü için iyi eski biraz daha kısadır

JavaScript (ES6, WebWorkers kullanarak), 233 215 bayt

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: İşçinin , çapraz kökenli politikalar açısından daha kompakt ve çapraz tarayıcıya sahip bir dizgeden çalıştırılma şeklinin yerini aldı. Hala webkitURLyerine nesne varsa URLve IE'de Safari'de çalışmaz .

Python 2, 130 bayt

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

Bu, Mego'nun cevabının bir türevi, ancak ayrı bir cevap olması gerektiğini düşündüğümden yeterince farklı. Windows üzerinde çalışmak için test edilmiştir.

Temel olarak, ebeveyn 8 kişilik uyku modundayken 7 saniye uyuyan 9 ipliği çıkarır. Sonra süreleri yazdırır. Örnek çıktı:

8.00059192923 71.0259046024

Windows'ta, time.clockilk aramadan bu yana duvar süresini ölçer.

Perl 6, 72 71 bayt

Bunu yapmanın daha kısa bir yolu olabilir

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

bu çıktılar

63.00660729694
7.0064013

Mathematica, 109 bayt

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

Anonim işlev Çalıştırmak için 7+ alt çekirdek içeren bir lisans gerektirir. Yükü hesaba katmamak için 9 saniye gerçek zamanlı ve 63 saniye çekirdek zaman alır. Yukarıdaki ifadeleri yalnızca bir kez çalıştırdığınızdan emin olun (bu nedenle çekirdekleri yeniden başlatmaya çalışmaz). Test yapmak:

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 bayt

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

Güncelleme sürümü: 106 bayt @ Ismael Miguel'den ödünç alınıyor çünkü uyku süresini kısaltmak ve aralıkları arttırmak için harika bir fikirdi.

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

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

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

ve asılsız

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

Lütfen evde denemeyin, çünkü bu iş parçacığı güvenli değildir.

Düzenle:

@ Bir Boschman ve @ Adám'in önerilerini aldım ve şimdi programımın çalışması 10 saniyeden az sürüyor ve 15 bayt daha kısa sürüyor.

C (pthreads ile), 339 336 335 bayt

#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 Bayt (env değişkeni için + 17) = 148 Bayt

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

Örnek çıktı:

7091,9.000014

Notlar:

7091 devir (100 / sn), yani program 70 saniye çalıştı

Eğer bir zamanlayıcıyı omp_get_wtime () dışında çalışacak bir zamanlayıcı bulursam çok kısa olabilirdi çünkü daha sonra include ifadesini de kaldırabilirim.

OMP_NUM_THREADS = 9 ile çalıştır

Ortak Lisp (SBCL) 166 bayt:

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

Bu sadece uyuyan iplikleri yumuşatır ve daha sonra toplam sürenin 60000 kenenin (yani sbcl'de 60'ların üzerinde olmasını) bekleyen bir dış ilmeğe sahip olan atomik artışı artırır. Sayaç, atomic-incf'nin değiştirebileceği yer türleriyle ilgili kısıtlamalar nedeniyle bir listede saklanır. Bu, daha hızlı makinelerde sonlandırmadan önce alan tükenebilir.

Ungolfed:

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

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

Çatallar, her biri 9 saniye bekleyecek 7 çocuk işlemi.

Örnek çıktı:

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

Örnek çalışma:

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

İksir, 168 bayt

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)

Örnek çalışma:

$ elixir thing.exs
64012846
4007547

Çıktı, programın, mikrosaniye cinsinden çalıştığı zamanın ardından beklediği toplam süredir.

Program 14 Tasksaniye sürecek ve her birinin üzerini haritalayarak bekleyecek ve daha sonra geçen zamanların toplamını bulacaktır. timerÖlçüm süresi için Erlang'ı kullanır .

Haskell, 278 271 262 246 bayt

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

!eylemde geçen süreyi ölçer a(ikinci argüman) ve bsonuca uygular (ilk argüman).

w uyku işlevidir.

mainölçülür ve sonuç yazdırılır ( print!...).

#olan replicateMbelirli bir hareketin N kez tekrar (ve dönen tgolf için).

Ölçülen parçanın içinde 9 iplik ( replicate 9 $ forkIO ...) 5^10milisaniye boyunca uykuda kalır (9.765625 saniye) ve sonucu ( writeChan) ana iplik ( newChan) tarafından oluşturulan bir boruya gönderir , bu da 9 sonucu toplar ve toplamı ( getChanContents >>= print . sum . take 9) yazdırır .

Çıktı:

87.938546708s
9.772032144s

Python 2,132 bayt

9 işlem oluşturmak ve her birinin 7 saniye boyunca uyumasını sağlamak için bir işlem havuzu kullanır.

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

Önce toplam biriken uyku süresini, ardından gerçek çalışma zamanını yazdırır:

$ python test.py
63.0631158352 7.04391384125

Yakut ( parallelcevherli), 123 116 bayt

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

Düzenleme: histocrat tarafından Ruby cevabından "Time.now" referansını ekledi.

Matlab, 75 bayt

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

Hızlı açıklama: parforİşçi havuzuna dağıtılmış bir döngü için paralel yaratır. ticve tocgeçen süreyi ölçün (ve bence MATLAB'deki en iyi adlandırılmış fonksiyonlardan biri). Son satır (toplam süre uyumayan ve gerçek zamanlı geçen bir dizi) bir noktalı virgülle sonlanmadığından çıkarılır.

Bununla birlikte, bunun tam bir 9 tam teşekküllü MATLAB süreci yarattığını unutmayın. O zaman bu özel programın, makinenizde ayrılan 10 saniye içinde bitmeyeceği ihtimalleri. Bununla birlikte, SSD'li bir üst uç sisteme kurulmuş Paralel Hesaplama araç kutusu dışında hiçbir araç kutusu olmayan bir MATLAB kurulumuyla sadece 10 saniye içinde bitirebileceklerini düşünüyorum. Gerekirse, daha fazla uyku daha az işlem olması için parametreleri ince ayar yapabilirsiniz.