# Wait a minute – in less than ten seconds

Using any type of parallelisation, wait multiple periods, for a total sleep time of at least a minute (but less than a minute and a half).

The program/function must terminate within 10 seconds and return (by any means and in any format) two values: the total elapsed time, and the total executed sleep time. Both time values have to have a precision of at least 0.1 seconds.

This is similar to the concept of man-hours: a job that takes 60 hours can be completed in only 6 hours if 10 workers are splitting the job. Here we can have 60 seconds of sleep time e.g. in 10 parallel threads, thus requiring only 6 seconds for the whole job to be completed.

### Example

The program MyProgram creates 14 threads, each thread sleeps for 5 seconds:

MyProgram[5.016,70.105]

The execution time is greater than 5 seconds, and the total sleep time is greater than 70 seconds because of overhead.

• I've read the question several times and I don't get it. Can you clarify a bit? Why "10 seconds" and a delay of "70 seconds"? How are all those times related? Jun 16, 2016 at 7:31
• How many threads can we assume will be executed in parallel? Jun 16, 2016 at 7:47
• What precision is required for the time in output? Jun 16, 2016 at 9:15
• I wonder if this will cause all the golfing language authors to engage in a mad dash to add multi-threading to their creations...
Jun 16, 2016 at 14:23
• @NoOneIsHere Ah, well, a properly implemented sleep method should not busy a core, so the number of threads may exceed the number of (virtual) processors.
Jun 16, 2016 at 15:08

## Python 2, 172 bytes

import threading as H,time as T
m=T.time
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

This requires an OS with time precision greater than 1 second to work properly (in other words, any modern OS). 8 threads are created which sleep for 9 seconds each, resulting in a realtime runtime of ~9 seconds, and a parallel runtime of ~72 seconds.

Though the official documentation says that the Thread constructor should be called with keyword arguments, I throw caution to the wind and use positional arguments anyway. The first argument (group) must be None, and the second argument is the target function.

nneonneo pointed out in the comments that attribute access (e.g. f.t) is shorter than list index access (e.g. t[0]). Unfortunately, in most cases, the few bytes gained from doing this would be lost by needing to create an object that allows user-defined attributes to be created at runtime. Luckily, functions support user-defined attributes at runtime, so I exploit this by saving the total time in the t attribute of f.

Try it online

Thanks to DenkerAffe for -5 bytes with the exec trick.

Thanks to kundor for -7 bytes by pointing out that the thread argument is unnecessary.

Thanks to nneonneo for -7 bytes from miscellaneous improvements.

• You can save two bytes by removing the argument to f(), and the last two arguments to Thread (thus removing 7 characters) and using t.append(m()-n) to avoid assigning a local variable t (using 5 more characters than +=.) Jun 16, 2016 at 15:50
• And you can save five more by keeping the sum instead of a list of times: initialize t with t=[0], replace the append by t[0]+=m()-n, and replace sum(t) by t[0]. Jun 16, 2016 at 15:57
• Thread names can be omitted. Jun 16, 2016 at 16:13
• @ppperry: not if you need to use the subsequent positional arguments (but as I mentioned in previous comments, you can actually elide those.) Jun 16, 2016 at 18:52
• Save three bytes by using import threading as H,time as t; save another two bytes by using z=H.Thread and map(z.join,r); save another two bytes by stashing the total time as an attribute (e.g. T.z+=m()-n) Jun 17, 2016 at 19:34

# Dyalog APL, 652723 21 bytes

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

I.e.:

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

Explanation:

• ⎕DL&¨9/7: spin off 9 threads, each of which waits for 7 seconds. ⎕DL returns the actual amount of time spent waiting, in seconds, which will be the same as its argument give or take a few milliseconds.
• ⎕TSYNC: wait for all threads to complete, and get the result for each thread.
• (⌈/,+/): return the longest execution time of one single thread (during the execution of which all other threads finished, so this is the actual runtime), followed by the sum of the execution time of all threads.

Try it online!

• This won't work if executed at 23:59:57. However, you're on the right track... While you are already the shortest, can you golf away another 40 bytes?
Jun 16, 2016 at 21:57
• @Adám: no, but I can golf away 38 bytes. It's quite obvious, I don't know why I didn't think of this the first time around. Jun 16, 2016 at 22:39
• There you go. Only another 6 bytes until you get a checkmark. The three things you have to do are pretty obvious too, saving 1, 2, and 3 bytes respectively.
Jun 16, 2016 at 22:43
• Very nice, you found number 1 and number 3. Number 2 isn't really golfing, as much as an implementation alternative...
Jun 16, 2016 at 23:23
• Number 2: As you don't need arguments, just make it into a tfn body.
Jun 17, 2016 at 19:25

# Bash + GNU utilities, 85

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

Forces the use of the time executable instead of the shell builtin by prefixing with a \.

Appends to a file j, which must be empty or non-existent at the start.

• What about a forking script like; if [ $1 -lt 9 ];then { ./a$(( $1 + 1 )) &};sleep 7;fi or somesuch? Would that be against the rules, or something I'm not understanding about the spec? [edit; I missed the requirement for output. Ooh, that makes it interesting!] Jun 17, 2016 at 17:48 • @DewiMorgan Yes, the output requirement makes it quite a bit harder. What you suggest could be golfed to something like (($1<9))&&$0$[$1+1]&sleep 7 Jun 17, 2016 at 18:01 # Go - 189 bytes Thanks @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)} Outputs (ms): 160.9939ms,60001 (160ms to wait 60.001 seconds) • Hello, and welcome to PPCG! This comment, @Rob In some languages the obvious solution is already (close to) the shortest. Besides, one way to view code-golf challenges is finding the shortest solution in EACH language. Otherwise Jelly will win most of the time... So: go ahead., does not mean that you should not try to golf your answer, but that it is OK if it does not win. Can you please add a golfed solution? Jun 16, 2016 at 15:51 • I'm sorry, I just read your edit. For golfed, you could maybe remove newlines and spaces, or change tot to something like q. Jun 16, 2016 at 15:52 • @NoOneIsHere, thanks for that, I'd overlooked that variable completely! Also banged together m and t. – Rob Jun 16, 2016 at 15:59 • codebeautify.org/javaviewer -- click minify – cat Jun 16, 2016 at 16:44 • codegolf.stackexchange.com/questions/41862/… – cat Jun 16, 2016 at 16:45 # C, 127 bytes (spins CPU) This solution spins the CPU instead of sleeping, and counts time using the times POSIX function (which measures CPU time consumed by the parent process and in all waited-for children). It forks off 7 processes which spin for 9 seconds apiece, and prints out the final times in C clocks (on most systems, 100 clock ticks = 1 second). 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]));} Sample output: 906,6347 meaning 9.06 seconds real time and 63.47 seconds total CPU time. For best results, compile with -std=c90 -m32 (force 32-bit code on a 64-bit machine). # Bash 196117114 93 bytes Updated to support better time precision by integrating suggestions from @manatwork and @Digital Trauma as well as a few other space optimizations: d()(date +$1%s.%N;)
b=d
for i in {1..8};{ (d -;sleep 8;d +)>>j&}
wait
bc<<<d-$b bc<<<<j Note that this assumes the j file is absent at the beginning. • function ss(), b=date +%sb=$SECONDS, expr $t +$i$[t+i], cat j$(<j) and generally see Tips for golfing in Bash about how to reduce it to this: pastebin.com/DDqUaDug Jun 16, 2016 at 9:22
• To reduce it more, better write directly a formula to the file j. I mean instead of 5↵5↵5↵… write +5+5+5… – then load it all directly into arithmetic evaluation and spare the second loop: pastebin.com/LB0BjDMZ Jun 16, 2016 at 9:26
• As minimum precision was specified later, forget the b=date +%sb=$SECONDS suggestion. Jun 16, 2016 at 9:36 • As bash does only integer arithmetic, the entire solution needs to be rewritten to use an external tool for calculation. Typically bc: pastebin.com/eYFEVUuz Jun 16, 2016 at 9:52 • @JuliePelletier Ok, I'll post it as my own answer. Still, I think you can still apply some of the golfing techniques to your answer without significantly changing the approach: pastebin.com/ssYzVs1n (93 bytes) Jun 16, 2016 at 17:19 ## 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])); Promises to wait 9 times for 7 seconds for a total of 63 seconds (actually 63.43 when I try), but only actually takes 7.05 seconds of real time when I try. # Scratch - 164 bytes (16 blocks) 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 See it in action here. Uses a variable called 't' and a sprite called 's'. The sprite creates clones of itself, each of which waits 8 seconds, and increments a variable clocking the entire wait time. At the end it says the total execution time and the total wait time (for example, 65.488 8.302). ## 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

Sets $d equal to Get-Date, and clears out any existing job histories with Get-Job | Remove-Job. We then loop 1..20|%{...} and each iteration execute Start-Job passing it the script block {$x=date;sleep 3;((date)-$x).ticks/1e7} for the job (meaning each job will execute that script block). We pipe that output to >$null in order to suppress the feedback (i.e., job name, status, etc.) that gets returned.

The script block sets $x to Get-Date, then Start-Sleep for 3 seconds, then takes a new Get-Date reading, subtracts$x, gets the .Ticks, and divides by 1e7 to get the seconds (with precision).

Back in the main thread, so long as any job is still -Status "Running", we spin inside an empty while loop. Once that's done, we Get-Job to pull up objects for all the existing jobs, pipe those to Receive-Job which will pull up the equivalent of STDOUT (i.e., what they output), -join the results together with +, and pipe it to iex (Invoke-Expression and similar to eval). This will output the resultant sleep time plus overhead.

The final line is similar, in that it gets a new date, subtracts the original date stamp $d, gets the .Ticks, and divides by 1e7 to output the total execution time. ### NB OK, so this is a little bendy of the rules. Apparently on first execution, PowerShell needs to load a bunch of .NET assemblies from disk for the various thread operations as they're not loaded with the default shell profile. Subsequent executions, because the assemblies are already in memory, work fine. If you leave the shell window idle long enough, you'll get PowerShell's built-in garbage collection to come along and unload all those assemblies, causing the next execution to take a long time as it re-loads them. I'm not sure of a way around this. You can see this in the execution times in the below runs. I started a fresh shell, navigated to my golfing directory, and executed the script. The first run was horrendous, but the second (executed immediately) worked fine. I then left the shell idle for a few minutes to let garbage collection come by, and then that run is again lengthy, but subsequent runs again work fine. ### Example runs 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> • I'll say that's fine. :-) – Adám Jun 16, 2016 at 15:14 # Javascript (ES6), 212203 145 bytes This code creates 10 images with a time interval of exactly 6 seconds each, upon loading. The execution time goes a tiny bit above it (due to overhead). This code overwrites everything in the document! 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) This assumes that you use a single-byte encoding for the backticks, which is required for the Javascript engine to do not trip. Alternativelly, if you don't want to spend 6 seconds waiting, here's a 1-byte-longer solution that finishes in less than a second: 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) The difference is that this code waits 600ms across 100 images. This will give a massive ammount of overhead. Old version (203 bytes): This code creates 10 iframes with a time interval of exactly 6 seconds each, instead of creating 10 images. 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.createElementiframe,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I) Original version (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.createElementiframe,I.src='javascript:setTimeout(_=>top.X(performance.now()),6e3)',D.body.appendChild(I)}) • +1 Very nice and different approach. What would happen in a single-threaded browser? – Adám Jun 16, 2016 at 18:15 • @Adám No change in behaviour. There would still be a delay of around 6 seconds. Firefox (a single-threaded browser) sometimes will output funny stuff like an execution time of 59999.<something>. Jun 16, 2016 at 18:17 # 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 I'm making a new answer since this uses a slightly different aproach. It generates a massive amount of setTimeouts, which are almost all executed with 4ms between them. Each interval is of 610 milliseconds, over a total of 99 intervals. M=(N=Date.now)(T=Y=0),eval('setTimeout("T+=N()-M,--i||alert([N()-M,T])",610);'.repeat(i=99)) It usually runs within 610ms, for a total execution time of around 60.5 seconds. This was tested on Google Chrome version 51.0.2704.84 m, on windows 8.1 x64. Old version (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)) # Clojure, 135120111 109 bytes (let[t #(System/nanoTime)s(t)f #(-(t)%)][(apply +(pmap #(let[s(t)](Thread/sleep 7e3)%(f s))(range 9)))(f s)]) Formatted version with named variables: (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 (in nanoseconds): [62999772966 7001137032] Changed format. Thanks Adám, I might have missed that format specification in the question when I read it. Changed to nanoTime for golfing abilities. Thanks cliffroot, I totally forgot about scientific notation and can't believe I didn't see apply. I think I used that in something I was golfing yesterday but never posted. You saved me 2 bytes. • Welcome to PPCG! Nice first post! You might be able to ask the OP about the output format. Jun 17, 2016 at 20:04 • No need to reverse. OP: by any means and in any format. – Adám Jun 19, 2016 at 18:36 • seems like you can use 7e3 instead of 7000 and use apply instead of reduce Jul 8, 2016 at 14:39 # Rust, 257, 247 bytes I use the same times as Mego's Python answer. Really the only slightly clever bit is using i-i to get a Duration of 0 seconds. 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());} Prints: 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: good old for loop is a bit shorter # JavaScript (ES6, using 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: replaced the way a worker is executed from a string with a more compact and cross-browser one, in the aspect of cross-origin policies. Won't work in Safari, if it still have webkitURL object instead of URL, and in IE. • I'm getting an error when I run this: { "message": "Uncaught SecurityError: Failed to construct 'Worker': Script at 'data:application/javascript,a%3Dnew%20Date()%3BsetTimeout(()%3D%3EpostMessage(new%20Date()-a)%2C5e3)' cannot be accessed from origin 'null'.", "filename": "http://stacksnippets.net/js", "lineno": 13, "colno": 45 } Jun 16, 2016 at 20:42 # 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);}} and 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); } } please don't try it at home, as this solution is not thread safe. # Edit: I took @A Boschman's and @Adám's suggestions, and now my program require less than 10 seconds to run, and it's shorter by 15 bytes. • You're inside a child of the Thread class, can't you omit the Thread. at the static sleep() method calls? Also, won't this program terminate in slightly over 10 seconds, disqualifying it? Jun 16, 2016 at 12:58 • @ABoschman thanks for suggestion, and its fixed by now, it doesn't run more than 10 sec anymore Jun 16, 2016 at 13:46 • Also, don't forget we have a great userbase of tips for golfing in java :) Jun 16, 2016 at 13:48 • This seems susceptible to read-modify-write race conditions. You don't have any sort of locking or anything around your static long t. I only mention this because the spec says "Both time values have to have a precision of at least 0.1 second." – Poke Jun 16, 2016 at 13:59 • You can remove the long before the s and add ,s to the static long t,i,s; to save a few bytes. Jun 17, 2016 at 7:36 # Perl 6, 72 71 bytes There might be a shorter way to do this say sum await map {start {sleep 7;now -ENTER now}},^9;say now -INIT now this outputs 63.00660729694 7.0064013 # PowerShell Core, 88 bytes$u=date
1..9|% -Pa{$d=date sleep 7 (date)-$d|% T*ls*}-Th 9|measure -su
(date)-$u|% T*ls* ## Explained$u=date                              # Execution start time
1..9|% -Pa{$d=date # Starts 9 threads sleep 7 # Sleeps for 7 seconds (date)-$d|% T*ls*}-Th 9|measure -su  # Gets the (T)ota(ls)econds for the current thread and sum them
(date)-$u|% T*ls* # Gets the script time in seconds ## Sample output # Mathematica, 109 bytes a=AbsoluteTiming;LaunchKernels@7;Plus@@@a@ParallelTable[#&@@a@Pause@9,{7},Method->"EvaluationsPerKernel"->1]& Anonymous function. Requires a license with 7+ sub-kernels to run. Takes 9 seconds realtime and 63 seconds kernel-time, not accounting for overhead. Make sure to only run the preceding statements once (so it doesn't try to re-launch kernels). Testing: 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} • Leave it to Wolfram to put license restrictions on forking a child process. Jun 17, 2016 at 4:59 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) Updated version: 106 bytes Borrowed from @Ismael Miguel as he had the great idea to lower sleep time and raise intervals. ((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) • Instead of d+=t()-s;if(!c)alert([t()-i,d]), you can write d+=t()-s;c||alert([t()-i,d]), which will save a few bytes. Also, if you remove the function and rewrite it all, you can compete with my 92-byte long solution: for(c=8,i=(t=Date.now)(d=0);c--;)setTimeout((c,s)=>{d+=t()-s;c||alert([t()-i,d])},8e3,c,t()). And yes, this one is also 92 bytes long. Jun 17, 2016 at 13:01 # C (with pthreads), 339336 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);} # 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 This is a derivation of Mego's answer, but it's sufficiently different that I thought it should be a separate answer. It is tested to work on Windows. Basically, it forks off 9 threads, which sleep for 7 seconds while the parent sleeps for 8. Then it prints out the times. Sample output: 8.00059192923 71.0259046024 On Windows, time.clock measures wall time since the first call. # Python 2, 132 bytes Uses a process pool to spawn 9 processes and let each one sleep for 7 seconds. 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 Prints total accumulated sleeptime first, then the actual runtime:$ python test.py
63.0631158352 7.04391384125

# Common Lisp (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)))))

This just spawns threads that sleep and then atomically increment the time took, with an outer-loop that spins waiting for the total time to be more than 60000 ticks (i.e. 60s on sbcl). The counter is stored in a list due to limitations to the types of places atomic-incf can modify. This may run out of space before terminating on faster machines.

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)))
(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;
[8.031, 64.055]