High level structures and procedures for parallelism.
Misc things.
(use-modules
(parallel))
(define (get-value x)
(sleep x)
(format #t "getting value: ~a\n" x)
x)
(pcall + (get-value 1) (get-value 2))
(pcall + (get-value 2) (get-value 1))
Extension of (ice-9 atomic), offering more operations.
(use-modules
(parallel atomic))
(define (make-atomic-counter)
(let ((counter (make-atomic-box 0)))
(lambda ()
(atomic-box-fetch-and-add! counter 1))))
Pthread like barrier.
(use-modules
(ice-9 threads)
(parallel barrier))
(letrec ((barrier (make-barrier 2))
(thread (begin-thread
(barrier)
(display "thread")
(newline))))
(sleep 1)
(display "not in thread")
(newline)
(barrier)
(join-thread thread))
Same as (ice-9 futures) but with work stealing workers.
(use-modules
(parallel futures))
(pk
(touch (future~ (+ 1 1))))
Wrapper around (ice-9 q).
(use-modules
(ice-9 threads)
(srfi srfi-26)
(parallel queue))
(define Q (make-queue))
(define thread
(begin-thread
(let loop ()
(let ((elem (pop-queue! Q)))
(display elem)
(newline))
(loop))))
(for-each
(cut push-queue! Q <>)
(iota 100))
Thread pool scheduler. One can create as many pool wanted. There's also the
eventually~
syntax that schedules expression on a globally defined pool.
(use-modules
(ice-9 threads)
(parallel schedule))
(eventually~
(display "foo")
(newline))
(let ((scheduler
(make-scheduler
#:name "my-scheduler"
#:max-thread (/ (current-process-count) 2)
#:port-if-error (open-output-file "my-scheduler.out"))))
(schedule-job~ scheduler
(lambda ()
(display "my job")
(newline)))
(scheduler-job/soon~ scheduler
(lambda ()
(display "Maybe this will run before my job!")
(newline))))
Pthread like semaphore.
(use-modules
(ice-9 threads)
(parallel semaphore))
(define sem (make-semaphore 0))
(define thread
(begin-thread
(wait-semaphore sem)
(display "wait!")
(newline)))
(display "post!")
(newline)
(post-semaphore sem)
(join-thread thread)
Do computation on vector like with SRFI-43, but in parallel.
(use-modules
((rnrs sorting) #:select (vector-sort))
(srfi srfi-43)
(parallel vector))
(define vector (vector-unfold values 100))
(pk
(parallel-vector-count even? vector))
(pk
(equal?
(vector-map (lambda (_ x) (1+ x)) vector)
(parallel-vector-map 1+ vector)))
(pk
(=
(/ (* 100 99) 2)
(parallel-vector-map-reduce + vector)))
(pk
(let ((v (vector-map (lambda _ (random 100)) vector)))
(equal?
(vector-sort < v)
(paralle-vector-sort < v))))