Tarefa

Usando qualquer tipo de paralelização, aguarde vários períodos, para um tempo total de sono de pelo menos um minuto (mas menos de um minuto e meio).

O programa / função deve terminar em 10 segundos e retornar (por qualquer meio e em qualquer formato) dois valores: o tempo total decorrido e o tempo total de suspensão executado. Ambos os valores de tempo devem ter uma precisão de pelo menos 0,1 segundos.

Isso é semelhante ao conceito de horas de trabalho: um trabalho que leva 60 horas pode ser concluído em apenas 6 horas se 10 trabalhadores estiverem dividindo o trabalho. Aqui podemos ter 60 segundos de tempo de suspensão, por exemplo, em 10 threads paralelos, exigindo apenas 6 segundos para que todo o trabalho seja concluído.

Exemplo

O programa MyProgram cria 14 threads, cada thread dorme por 5 segundos:

MyProgram → [5.016,70.105]

O tempo de execução é maior que 5 segundos e o tempo total de suspensão é maior que 70 segundos devido a sobrecarga.

Dyalog APL, 65 27 23 21 bytes

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

Ou seja:

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

Explicação:

• ⎕DL&¨9/7: desmonte 9 threads, cada um deles aguardando 7 segundos. ⎕DLretorna a quantidade real de tempo gasto em espera, em segundos, que será o mesmo que seu argumento em alguns milissegundos.
• ⎕TSYNC: aguarde a conclusão de todos os threads e obtenha o resultado para cada thread.
• (⌈/,+/): retorna o tempo de execução mais longo de um único encadeamento (durante a execução em que todos os outros encadeamentos terminaram, portanto esse é o tempo de execução real), seguido pela soma do tempo de execução de todos os encadeamentos.

Experimente online!

Python 2, 172 bytes

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

Isso requer um sistema operacional com precisão de tempo maior que 1 segundo para funcionar corretamente (em outras palavras, qualquer sistema operacional moderno). São criados 8 threads que dormem por 9 segundos cada, resultando em um tempo de execução em tempo real de ~ 9 segundos e em um tempo de execução paralelo de ~ 72 segundos.

Embora a documentação oficial diga que o Threadconstrutor deve ser chamado com argumentos de palavra-chave, atento ao vento e uso argumentos posicionais de qualquer maneira. O primeiro argumento ( group) deve ser Nonee o segundo argumento é a função de destino.

nneonneo apontou nos comentários que atribuir acesso (por exemplo f.t) é menor que o acesso ao índice de lista (por exemplo t[0]). Infelizmente, na maioria dos casos, os poucos bytes obtidos com isso seriam perdidos pela necessidade de criar um objeto que permita a criação de atributos definidos pelo usuário em tempo de execução. Felizmente, as funções suportam atributos definidos pelo usuário em tempo de execução, então eu exploro isso economizando o tempo total no tatributo de f.

Experimente online

Graças à DenkerAffe por -5 bytes com o exectruque.

Graças ao kundor por -7 bytes, apontando que o argumento do thread é desnecessário.

Graças a nneonneo por -7 bytes de melhorias diversas.

Utilitários Bash + GNU, 85

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

Força o uso do timeexecutável em vez do shell incorporado, prefixando com a \.

Anexa a um arquivo j, que deve estar vazio ou inexistente no início.

Ir - 189 bytes

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

Saídas (ms): 160.9939ms, 60001 (160ms para aguardar 60.001 segundos)

Bash 196 117 114 93 bytes

Atualizado para oferecer melhor precisão do tempo, integrando sugestões do @manatwork e do @Digital Trauma, além de algumas outras otimizações de espaço:

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

Observe que isso pressupõe que o jarquivo está ausente no início.

JavaScript (ES6), 148 bytes

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

Promete esperar 9 vezes por 7 segundos, durante um total de 63 segundos (na verdade 63,43 quando tento), mas na verdade leva apenas 7,05 segundos em tempo real quando tento.

C, 127 bytes (gira a CPU)

Essa solução gira a CPU em vez de dormir e conta o tempo usando a timesfunção POSIX (que mede o tempo da CPU consumido pelo processo pai e em todos os filhos esperados).

Ele realiza 7 processos, que são girados por 9 segundos cada, e imprime os tempos finais nos relógios C (na maioria dos sistemas, 100 tiques = 1 segundo).

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

Saída de amostra:

906,6347

ou seja, 9,06 segundos em tempo real e 63,47 segundos no tempo total da CPU.

Para obter melhores resultados, compile com -std=c90 -m32(force o código de 32 bits em uma máquina de 64 bits).

PowerShell v4, 144 bytes

$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

Define $digual a Get-Datee limpa todos os históricos de trabalhos existentes Get-Job | Remove-Job. Em seguida, fazemos um loop 1..20|%{...}e cada iteração é executada Start-Jobpassando o bloco de scripts {$x=date;sleep 3;((date)-$x).ticks/1e7}para o trabalho (o que significa que cada trabalho executará esse bloco de script). Canalizamos essa saída para >$nullsuprimir o feedback (nome do trabalho, status etc.) que é retornado.

O bloco de script define $xcomo Get-Date, então, Start-Sleeppor 3segundos, em seguida, recebe uma nova Get-Dateleitura, subtrai $x, obtém o .Tickse divide por 1e7para obter os segundos (com precisão).

De volta à thread principal, desde que qualquer trabalho ainda seja -Sobrigatório "Running", giramos dentro de um whileloop vazio . Uma vez feito isso, Get-Jobpuxamos objetos para todos os trabalhos existentes, canalizamos aqueles para os Receive-Jobquais o equivalente a STDOUT (ou seja, o que eles produzem), -joinos resultados juntos +, e canalizamos iex( Invoke-Expressione semelhante a eval). Isso produzirá o tempo de suspensão resultante mais a sobrecarga.

A linha final é semelhante, na medida em que obtém uma nova data, subtrai o carimbo de data original $d, obtém o .Tickse divide por 1e7para gerar o tempo total de execução.

NB

OK, então isso é um pouco flexível das regras. Aparentemente, na primeira execução, o PowerShell precisa carregar vários assemblies .NET do disco para as várias operações de encadeamento, pois elas não são carregadas com o perfil de shell padrão. Execuções subseqüentes , porque os assemblies já estão na memória, funcionam bem. Se você deixar a janela do shell inativa por tempo suficiente, você fará com que a coleta de lixo interna do PowerShell apareça e descarregue todos esses assemblies, fazendo com que a próxima execução demore muito tempo enquanto ela é carregada novamente. Eu não tenho certeza de uma maneira de contornar isso.

Você pode ver isso nos tempos de execução nas execuções abaixo. Comecei um novo shell, naveguei para o meu diretório de golfe e executei o script. A primeira corrida foi horrenda, mas a segunda (executada imediatamente) funcionou bem. Em seguida, deixei o shell inativo por alguns minutos para permitir a coleta de lixo e, em seguida, essa execução é novamente demorada, mas as execuções subseqüentes novamente funcionam bem.

Execuções de exemplo

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 bytes

Esse código cria 10 imagens com um intervalo de tempo de exatamente 6 segundos cada, após o carregamento.

O tempo de execução vai um pouco acima dele (devido à sobrecarga).

Este código substitui tudo no documento!

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)

Isso pressupõe que você use uma codificação de byte único para os backticks, necessária para o mecanismo Javascript não desarmar.

Como alternativa, se você não quiser esperar 6 segundos, aqui está uma solução de 1 byte a mais que termina em menos de um segundo:

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)

A diferença é que esse código espera 600ms em 100 imagens. Isso dará uma enorme quantidade de sobrecarga.

Versão antiga (203 bytes):

Esse código cria 10 iframes com um intervalo de tempo de exatamente 6 segundos cada, em vez de criar 10 imagens.

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)

Versão original (212 bytes):

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 bytes

Estou fazendo uma nova resposta, pois isso usa uma abordagem um pouco diferente.

Ele gera uma quantidade enorme de setTimeouts, que são quase todos executados com 4ms entre eles.

Cada intervalo é de 610 milissegundos, em um total de 99 intervalos.

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

Geralmente, é executado em 610ms, para um tempo total de execução de cerca de 60,5 segundos.

Isso foi testado no Google Chrome versão 51.0.2704.84 m, no Windows 8.1 x64.

Versão antiga (108 bytes):

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

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

Veja em ação aqui .

Usa uma variável chamada 't' e um sprite chamado 's'. O sprite cria clones de si mesmo, cada um deles aguardando 8 segundos, e incrementa uma variável com o tempo inteiro de espera. No final, indica o tempo total de execução e o tempo total de espera (por exemplo 65.488 8.302).

Clojure, 135 120 111 109 bytes

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

Versão formatada com variáveis ​​nomeadas:

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

saída (em nanossegundos):

[62999772966 7001137032]

Formato alterado. Obrigado Adám, eu poderia ter perdido essa especificação de formato na pergunta quando a li.

Alterado para nanoTime para habilidades de golfe.

Obrigado, cliffroot, esqueci completamente a notação científica e não acredito que não vi apply. Acho que usei isso em algo que jogava golfe ontem, mas nunca postei. Você me salvou 2 bytes.

Ferrugem, 257 , 247 bytes

Uso os mesmos tempos da resposta Python do Mego.

Realmente, o único bit um pouco inteligente é usar ii para obter uma duração de 0 segundos.

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

Impressões:

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

Edit: bom velho para loop é um pouco mais curto

JavaScript (ES6, usando WebWorkers), 233 215 bytes

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: substituiu a maneira como um trabalhador é executado a partir de uma string por um mais compacto e entre navegadores, no aspecto das políticas de origem. Não funcionará no Safari, se ele ainda tiver um webkitURLobjeto em vez de URLno IE.

Python 2, 130 bytes

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

Esta é uma derivação da resposta de Mego, mas é suficientemente diferente que eu pensei que deveria ser uma resposta separada. Foi testado para funcionar no Windows.

Basicamente, ele obtém 9 threads, que dormem por 7 segundos enquanto o pai dorme por 8 anos. Depois, imprime as horas. Saída de amostra:

8.00059192923 71.0259046024

No Windows, time.clockmede o tempo de parede desde a primeira chamada.

Perl 6, 72 71 bytes

Pode haver uma maneira mais curta de fazer isso

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

isso gera

63.00660729694
7.0064013

Mathematica, 109 bytes

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

Função anônima. Requer uma licença com mais de 7 sub-kernels para executar. Leva 9 segundos em tempo real e 63 segundos em tempo de kernel, sem levar em conta a sobrecarga. Certifique-se de executar apenas as instruções anteriores uma vez (para não tentar reiniciar os kernels). Testando:

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 bytes

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

Versão atualizada: 106 bytes Emprestado do @Ismael Miguel, pois ele teve a ótima idéia de diminuir o tempo de sono e aumentar os intervalos.

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

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

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

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

não tente em casa, pois esta solução não é segura para threads.

Editar:

Peguei as sugestões de @A Boschman e @ Adám, e agora meu programa leva menos de 10 segundos para ser executado, e é mais curto em 15 bytes.

C (com pthreads), 339 336 335 bytes

#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 para a variável 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);}

Saída de exemplo:

7091,9.000014

Notas:

7091 está em ciclos (100 / s), portanto, o programa foi executado por 70 segundos

Poderia ser muito mais curto se eu descobrisse uma maneira de fazer com que um cronômetro funcionasse além de omp_get_wtime (), porque então eu poderia remover a instrução include também.

Execute com OMP_NUM_THREADS = 9

Lisp comum (SBCL) 166 bytes:

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

Isso gera threads que dormem e aumentam atomicamente o tempo gasto, com um loop externo que gira esperando que o tempo total seja superior a 60000 ticks (ou seja, 60s no sbcl). O contador é armazenado em uma lista devido a limitações nos tipos de locais que o atomic-incf pode modificar. Isso pode ficar sem espaço antes de terminar em máquinas mais rápidas.

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 bytes

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

Garfo 7 processos filho, cada um dos quais espera 9 segundos.

Saída de amostra:

perl wait-one-minute.pl
9.00925707817078-63.001741

Groovy, 158 143 caracteres

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

Exemplo de execução:

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

Elixir, 168 bytes

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)

Exemplo de execução:

$ elixir thing.exs
64012846
4007547

A saída é o tempo total esperado, seguido pelo tempo em que o programa foi executado, em microssegundos.

O programa gera 14 Tasksegundos e aguarda cada um deles mapeando-os e depois encontra a soma do tempo decorrido. Ele usa o Erlang timerpara medir o tempo.

Haskell, 278 271 262 246 bytes

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

!mede o tempo gasto pela ação a(segundo argumento) e aplica-se b(primeiro argumento) ao resultado.

w é a função do sono.

mainé medido em si e o resultado é impresso ( print!...).

#é replicateMrepetir a ação especificada N vezes (e retornar tporque joga golfe).

Dentro da peça medida, 9 threads ( replicate 9 $ forkIO ...) dormem por 5^10milissegundos (9.765625 segundos) e postam o resultado ( writeChan) em um tubo criado pelo thread principal ( newChan), que soma os 9 resultados e imprime o total ( getChanContents >>= print . sum . take 9).

Resultado:

87.938546708s
9.772032144s

Python 2, 132 bytes

Usa um pool de processos para gerar 9 processos e deixar cada um dormir por 7 segundos.

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

Imprime o total de sono acumulado primeiro, depois o tempo de execução real:

$ python test.py
63.0631158352 7.04391384125

Ruby (com parallelgema), 123 116 bytes

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

Edit: Adicionada a referência "Time.now" da resposta Ruby do histocrat.

Matlab, 75 bytes

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

Explicação rápida: parforcria um loop for paralelo, distribuído pelo conjunto de trabalhadores. tice tocmedir o tempo decorrido (e, na minha opinião, é uma das funções mais bem nomeadas do MATLAB). A última linha (uma matriz com o tempo total gasto e o tempo real decorrido) é gerada, pois não é finalizada com ponto e vírgula.

Observe, no entanto, que isso cria 9 processos MATLAB completos. As chances são de que esse programa em particular não seja concluído nos 10 segundos alocados em sua máquina. No entanto, acho que com uma instalação do MATLAB que não possui caixas de ferramentas, exceto a caixa de ferramentas Parallel Computing instalada - instalada em um sistema high-end com SSD - pode ser concluída em 10 segundos. Se necessário, você pode ajustar os parâmetros para que menos processos durmam mais.