diff --git a/.forgejo/workflows/build-website.yaml b/.forgejo/workflows/demo.yaml similarity index 61% rename from .forgejo/workflows/build-website.yaml rename to .forgejo/workflows/demo.yaml index ae6c4da..c3f4156 100644 --- a/.forgejo/workflows/build-website.yaml +++ b/.forgejo/workflows/demo.yaml @@ -1,7 +1,7 @@ on: push: branches: - - trunk + - actions-test jobs: test: runs-on: host @@ -10,17 +10,13 @@ jobs: - run: git clone --depth=1 https://$FORGEJO_TOKEN@forge.cbaines.net/cbaines/guile-knots.git --branch=pages knots-pages - run: | cd knots-trunk - guix shell -D -f guix-dev.scm -- documenta api "knots.scm knots/" + guix shell -D -f guix-dev.scm -- documenta api knots guix shell texinfo -- makeinfo --css-ref=https://luis-felipe.gitlab.io/texinfo-css/static/css/texinfo-7.css --no-split --html -c SHOW_TITLE=true -o ../knots-pages/index.html doc/index.texi - run: | cd knots-pages git add . - if [[ -z "$(git status -s)" ]]; then - echo "Nothing to push" - else - git config user.email "" - git config user.name "Automatic website updater" - git commit -m "Automatic website update" - git push - fi + git config user.email "" + git config user.name "Automatic website updater" + git commit -m "Automatic website update" + git push diff --git a/Makefile.am b/Makefile.am index 5551fbe..21851ae 100644 --- a/Makefile.am +++ b/Makefile.am @@ -7,22 +7,20 @@ SOURCES = \ knots/promise.scm \ knots/queue.scm \ knots/resource-pool.scm \ - knots/sort.scm \ - knots/thread-pool.scm \ knots/timeout.scm \ - knots/web-server.scm + knots/web-server.scm \ + knots/thread-pool.scm SCM_TESTS = \ tests/non-blocking.scm \ - tests/non-blocking.scm \ - tests/parallelism.scm \ tests/promise.scm \ - tests/queue.scm \ - tests/resource-pool.scm \ - tests/sort.scm \ - tests/thread-pool.scm \ tests/timeout.scm \ - tests/web-server.scm + tests/non-blocking.scm \ + tests/queue.scm \ + tests/web-server.scm \ + tests/parallelism.scm \ + tests/resource-pool.scm \ + tests/thread-pool.scm TESTS_GOBJECTS = $(SCM_TESTS:%.scm=%.go) diff --git a/knots.scm b/knots.scm index 765db5a..05b2a1a 100644 --- a/knots.scm +++ b/knots.scm @@ -1,12 +1,7 @@ (define-module (knots) #:use-module (srfi srfi-1) #:use-module (ice-9 match) - #:use-module (ice-9 threads) - #:use-module (ice-9 binary-ports) #:use-module (ice-9 suspendable-ports) - #:use-module (rnrs bytevectors) - #:use-module (fibers) - #:use-module (fibers channels) #:use-module (fibers conditions) #:use-module (system repl debug) #:export (call-with-default-io-waiters @@ -15,18 +10,12 @@ call-with-sigint - display/knots - simple-format/knots - format/knots - &knots-exception make-knots-exception knots-exception? knots-exception-stack - print-backtrace-and-exception/knots - - spawn-fiber/knots)) + print-backtrace-and-exception/knots)) (define (call-with-default-io-waiters thunk) (parameterize @@ -59,70 +48,6 @@ ;; restore original C handler. (sigaction SIGINT #f)))))) -(define (call-with-temporary-thread thunk) - (let ((channel (make-channel))) - (call-with-new-thread - (lambda () - (call-with-default-io-waiters - (lambda () - (with-exception-handler - (lambda (exn) - (put-message channel `(exception . ,exn))) - (lambda () - (with-exception-handler - (lambda (exn) - (let ((stack - (match (fluid-ref %stacks) - ((stack-tag . prompt-tag) - (make-stack #t - 0 prompt-tag - 0 (and prompt-tag 1))) - (_ - (make-stack #t))))) - (raise-exception - (make-exception - exn - (make-knots-exception stack))))) - (lambda () - (call-with-values thunk - (lambda values - (put-message channel `(values ,@values))))))) - #:unwind? #t))))) - - (match (get-message channel) - (('values . results) - (apply values results)) - (('exception . exn) - (raise-exception exn))))) - -(define* (display/knots obj #:optional (port (current-output-port))) - (put-bytevector - port - (string->utf8 - (call-with-output-string - (lambda (port) - (display obj port)))))) - -(define (simple-format/knots port s . args) - (let ((str (apply simple-format #f s args))) - (if (eq? #f port) - str - (display/knots - str - (if (eq? #t port) - (current-output-port) - port))))) - -(define (format/knots port s . args) - (let ((str (apply format #f s args))) - (if (eq? #f port) - str - (display/knots - str - (if (eq? #t port) - (current-output-port) - port))))) - (define &knots-exception (make-exception-type '&knots-exception &exception @@ -142,58 +67,6 @@ (define* (print-backtrace-and-exception/knots exn #:key (port (current-error-port))) - (define (get-string port stack) - (define stack-len - (stack-length stack)) - - (let ((knots-stacks - (map knots-exception-stack - (filter knots-exception? - (simple-exceptions exn))))) - - (let* ((stack-vec - (stack->vector stack)) - (stack-vec-length - (vector-length stack-vec))) - (print-frames (list->vector - (drop - (vector->list stack-vec) - (if (< stack-vec-length 5) - 0 - 4))) - port - #:count (stack-length stack))) - (for-each - (lambda (stack) - (let* ((stack-vec - (stack->vector stack)) - (stack-vec-length - (vector-length stack-vec))) - (print-frames (list->vector - (drop - (vector->list stack-vec) - (if (< stack-vec-length 4) - 0 - 3))) - port - #:count (stack-length stack)))) - knots-stacks) - (print-exception - port - (if (null? knots-stacks) - (stack-ref stack - (if (< stack-len 4) - stack-len - 4)) - (let* ((stack (last knots-stacks)) - (stack-len (stack-length stack))) - (stack-ref stack - (if (< stack-len 3) - stack-len - 3)))) - '%exception - (list exn)))) - (let* ((stack (match (fluid-ref %stacks) ((stack-tag . prompt-tag) @@ -202,59 +75,56 @@ 0 (and prompt-tag 1))) (_ (make-stack #t)))) - (string-port - (open-output-string)) + (stack-len + (stack-length stack)) (error-string - (with-exception-handler - (lambda (exn) - (display/knots (get-output-string string-port) - port) - (close-output-port string-port) - (display/knots "\n\n" port) + (call-with-output-string + (lambda (port) + (let ((knots-stacks + (map knots-exception-stack + (filter knots-exception? + (simple-exceptions exn))))) - (let* ((stack (make-stack #t)) - (backtrace - (call-with-output-string - (lambda (port) - (display-backtrace stack port) - (newline port))))) - (display/knots backtrace)) - (simple-format/knots + (let* ((stack-vec + (stack->vector stack)) + (stack-vec-length + (vector-length stack-vec))) + (print-frames (list->vector + (drop + (vector->list stack-vec) + (if (< stack-vec-length 5) + 0 + 4))) + port + #:count (stack-length stack))) + (for-each + (lambda (stack) + (let* ((stack-vec + (stack->vector stack)) + (stack-vec-length + (vector-length stack-vec))) + (print-frames (list->vector + (drop + (vector->list stack-vec) + (if (< stack-vec-length 4) + 0 + 3))) + port + #:count (stack-length stack)))) + knots-stacks) + (print-exception port - "\nexception in print-backtrace-and-exception/knots: ~A\n" - exn) - (raise-exception exn)) - (lambda () - (get-string string-port stack) - (let ((str (get-output-string string-port))) - (close-output-port string-port) - str))))) - (display/knots error-string port))) - -(define* (spawn-fiber/knots thunk #:optional scheduler #:key parallel?) - (spawn-fiber - (lambda () - (with-exception-handler - (lambda (exn) - (display/knots "Uncaught exception in task:\n" - (current-error-port)) - (print-backtrace-and-exception/knots exn)) - (lambda () - (with-exception-handler - (lambda (exn) - (let ((stack - (match (fluid-ref %stacks) - ((stack-tag . prompt-tag) - (make-stack #t - 0 prompt-tag - 0 (and prompt-tag 1))) - (_ - (make-stack #t))))) - (raise-exception - (make-exception - exn - (make-knots-exception stack))))) - thunk)) - #:unwind? #t)) - scheduler - #:parallel? parallel?)) + (if (null? knots-stacks) + (stack-ref stack + (if (< stack-len 4) + stack-len + 4)) + (let* ((stack (last knots-stacks)) + (stack-len (stack-length stack))) + (stack-ref stack + (if (< stack-len 3) + stack-len + 3)))) + '%exception + (list exn))))))) + (display error-string port))) diff --git a/knots/parallelism.scm b/knots/parallelism.scm index 7631055..f8b2b8b 100644 --- a/knots/parallelism.scm +++ b/knots/parallelism.scm @@ -20,9 +20,6 @@ (define-module (knots parallelism) #:use-module (srfi srfi-1) #:use-module (srfi srfi-71) - #:use-module (srfi srfi-9) - #:use-module (srfi srfi-9 gnu) - #:use-module (srfi srfi-43) #:use-module (ice-9 match) #:use-module (ice-9 control) #:use-module (ice-9 exceptions) @@ -30,7 +27,6 @@ #:use-module (fibers channels) #:use-module (fibers operations) #:use-module (knots) - #:use-module (knots resource-pool) #:export (fibers-batch-map fibers-map @@ -42,13 +38,7 @@ fibers-parallel fibers-let - fiberize - - make-parallelism-limiter - parallelism-limiter? - destroy-parallelism-limiter - call-with-parallelism-limiter - with-parallelism-limiter)) + fiberize)) (define (defer-to-parallel-fiber thunk) (let ((reply (make-channel))) @@ -58,7 +48,7 @@ (lambda (exn) (put-message reply - (cons 'exception exn))) + (list 'exception exn))) (lambda () (with-exception-handler (lambda (exn) @@ -79,7 +69,7 @@ (lambda () (start-stack #t (thunk))) (lambda vals - (put-message reply (cons 'result vals))))))) + (put-message reply vals)))))) #:unwind? #t)) #:parallel? #t) reply)) @@ -89,16 +79,13 @@ reply-channels))) (map (match-lambda - (('exception . exn) + (('exception exn) (raise-exception exn)) - (('result . vals) - (apply values vals))) + (result + (apply values result))) responses))) (define (fibers-batch-map proc parallelism-limit . lists) - "Map PROC over LISTS in parallel, with a PARALLELISM-LIMIT. If any of -the invocations of PROC raise an exception, this will be raised once -all of the calls to PROC have finished." (define vecs (map (lambda (list-or-vec) (if (vector? list-or-vec) list-or-vec @@ -118,18 +105,9 @@ all of the calls to PROC have finished." (channel-indexes '())) (if (and (eq? #f next-to-process-index) (null? channel-indexes)) - (let ((processed-result-vec - (vector-map - (lambda (_ result-or-exn) - (match result-or-exn - (('exception . exn) - (raise-exception exn)) - (('result . vals) - (car vals)))) - result-vec))) - (if (vector? (first lists)) - processed-result-vec - (vector->list processed-result-vec))) + (if (vector? (first lists)) + result-vec + (vector->list result-vec)) (if (or (= (length channel-indexes) (min parallelism-limit vecs-length)) @@ -145,13 +123,18 @@ all of the calls to PROC have finished." (get-operation (vector-ref result-vec index)) (lambda (result) - (vector-set! result-vec - index - result) - (values next-to-process-index - (lset-difference = - channel-indexes - (list index)))))) + (match result + (('exception exn) + (raise-exception exn)) + (_ + (vector-set! result-vec + index + (first result)) + + (values next-to-process-index + (lset-difference = + channel-indexes + (list index)))))))) channel-indexes))))) (loop new-index new-channel-indexes)) @@ -174,14 +157,9 @@ all of the calls to PROC have finished." channel-indexes))))))) (define (fibers-map proc . lists) - "Map PROC over LISTS in parallel, running up to 20 fibers in - PARALLEL. If any of the invocations of PROC raise an exception, this -will be raised once all of the calls to PROC have finished." (apply fibers-batch-map proc 20 lists)) (define (fibers-batch-for-each proc parallelism-limit . lists) - "Call PROC on LISTS, running up to PARALLELISM-LIMIT fibers in -parallel." (apply fibers-batch-map (lambda args (apply proc args) @@ -192,13 +170,10 @@ parallel." *unspecified*) (define (fibers-for-each proc . lists) - "Call PROC on LISTS, running up to 20 fibers in parallel." (apply fibers-batch-for-each proc 20 lists)) (define-syntax fibers-parallel (lambda (x) - "Run each expression in parallel. If any expression raises an - exception, this will be raised after all exceptions have finished." (syntax-case x () ((_ e0 ...) (with-syntax (((tmp0 ...) (generate-temporaries (syntax (e0 ...))))) @@ -209,16 +184,12 @@ parallel." (apply values (fetch-result-of-defered-thunks tmp0 ...)))))))) (define-syntax-rule (fibers-let ((v e) ...) b0 b1 ...) - "Let, but run each binding in a fiber in parallel." (call-with-values (lambda () (fibers-parallel e ...)) (lambda (v ...) b0 b1 ...))) (define* (fibers-map-with-progress proc lists #:key report) - "Map PROC over LISTS, calling #:REPORT if specified after each -invocation of PROC finishes. REPORT is passed the results for each - element of LISTS, or #f if no result has been received yet." (let loop ((channels-to-results (apply map (lambda args @@ -239,8 +210,8 @@ invocation of PROC finishes. REPORT is passed the results for each (match-lambda ((#f . ('exception . exn)) (raise-exception exn)) - ((#f . ('result . vals)) - (car vals))) + ((#f . ('result . val)) + val)) channels-to-results) (loop (perform-operation @@ -257,7 +228,12 @@ invocation of PROC finishes. REPORT is passed the results for each (map (match-lambda ((c . r) (if (eq? channel c) - (cons #f result) + (cons #f + (match result + (('exception . exn) + result) + (_ + (cons 'result result)))) (cons c r)))) channels-to-results))) #f)))) @@ -278,7 +254,7 @@ invocation of PROC finishes. REPORT is passed the results for each reply-channel (with-exception-handler (lambda (exn) - (cons 'exception exn)) + (list 'exception exn)) (lambda () (with-exception-handler (lambda (exn) @@ -309,32 +285,5 @@ invocation of PROC finishes. REPORT is passed the results for each (put-message input-channel (cons reply-channel args)) (match (get-message reply-channel) (('result . vals) (apply values vals)) - (('exception . exn) + (('exception exn) (raise-exception exn)))))) - -(define-record-type - (make-parallelism-limiter-record resource-pool) - parallelism-limiter? - (resource-pool parallelism-limiter-resource-pool)) - -(define* (make-parallelism-limiter limit #:key (name "unnamed")) - (make-parallelism-limiter-record - (make-fixed-size-resource-pool - (iota limit) - #:name name))) - -(define (destroy-parallelism-limiter parallelism-limiter) - (destroy-resource-pool - (parallelism-limiter-resource-pool - parallelism-limiter))) - -(define* (call-with-parallelism-limiter parallelism-limiter thunk) - (call-with-resource-from-pool - (parallelism-limiter-resource-pool parallelism-limiter) - (lambda _ - (thunk)))) - -(define-syntax-rule (with-parallelism-limiter parallelism-limiter exp ...) - (call-with-parallelism-limiter - parallelism-limiter - (lambda () exp ...))) diff --git a/knots/promise.scm b/knots/promise.scm index c01d219..9df376b 100644 --- a/knots/promise.scm +++ b/knots/promise.scm @@ -28,7 +28,6 @@ #:export (fibers-promise? fibers-delay - fibers-delay/eager fibers-force fibers-promise-reset fibers-promise-result-available?)) @@ -83,10 +82,7 @@ (make-exception exn (make-knots-exception stack))))) - (lambda () - (start-stack - #t - ((fibers-promise-thunk fp)))))) + (fibers-promise-thunk fp))) #:unwind? #t)) (lambda vals (atomic-box-set! (fibers-promise-values-box fp) @@ -106,20 +102,6 @@ (raise-exception res) (apply values res)))))) - -(define (fibers-delay/eager thunk) - (let ((promise (fibers-delay thunk))) - (spawn-fiber - (lambda () - (with-exception-handler - (lambda _ - ;; Silently handle this exception - #f) - (lambda () - (fibers-force promise)) - #:unwind? #t))) - promise)) - (define (fibers-promise-reset fp) (atomic-box-set! (fibers-promise-values-box fp) #f)) diff --git a/knots/resource-pool.scm b/knots/resource-pool.scm index bdaad8f..da52051 100644 --- a/knots/resource-pool.scm +++ b/knots/resource-pool.scm @@ -21,9 +21,7 @@ #:use-module (srfi srfi-1) #:use-module (srfi srfi-9) #:use-module (srfi srfi-9 gnu) - #:use-module (srfi srfi-43) #:use-module (srfi srfi-71) - #:use-module (ice-9 q) #:use-module (ice-9 match) #:use-module (ice-9 exceptions) #:use-module (fibers) @@ -34,10 +32,9 @@ #:use-module (fibers conditions) #:use-module (knots) #:use-module (knots parallelism) - #:export (make-fixed-size-resource-pool - make-resource-pool + #:export (resource-pool? - resource-pool? + make-resource-pool resource-pool-name resource-pool-channel resource-pool-configuration @@ -76,431 +73,24 @@ (record-constructor &resource-pool-abort-add-resource)) (define resource-pool-abort-add-resource-error? - (exception-predicate &resource-pool-abort-add-resource)) + (record-predicate &resource-pool-abort-add-resource)) (define-record-type (make-resource-pool-record name channel destroy-condition configuration) resource-pool? (name resource-pool-name) - (channel resource-pool-channel - set-resource-pool-channel!) + (channel resource-pool-channel) (destroy-condition resource-pool-destroy-condition) (configuration resource-pool-configuration)) (set-record-type-printer! (lambda (resource-pool port) - (display/knots + (display (simple-format #f "#" (resource-pool-name resource-pool)) port))) -(define (safe-deq q) - (if (null? (car q)) - #f - (let ((it (caar q)) - (next (cdar q))) - (if (null? next) - (set-cdr! q #f)) - (set-car! q next) - it))) - -(define-record-type - (make-resource-details value checkout-count last-used) - resource-details? - (value resource-details-value) - (checkout-count resource-details-checkout-count - set-resource-details-checkout-count!) - (last-used resource-details-last-used - set-resource-details-last-used!)) - -(define-inlinable (increment-resource-checkout-count! resource) - (set-resource-details-checkout-count! - resource - (1+ (resource-details-checkout-count resource)))) - -(define-inlinable (decrement-resource-checkout-count! resource) - (set-resource-details-checkout-count! - resource - (1+ (resource-details-checkout-count resource)))) - -(define (spawn-fiber-for-checkout channel - reply-channel - reply-timeout - resource-id - resource) - (spawn-fiber - (lambda () - (let ((checkout-success? - (perform-operation - (choice-operation - (wrap-operation - (put-operation reply-channel - (list 'success resource-id resource)) - (const #t)) - (wrap-operation (sleep-operation - reply-timeout) - (const #f)))))) - (unless checkout-success? - (put-message - channel - (list 'return-failed-checkout resource-id))))))) - -(define* (make-fixed-size-resource-pool resources-list-or-vector - #:key - (delay-logger (const #f)) - (duration-logger (const #f)) - scheduler - (name "unnamed") - default-checkout-timeout - default-max-waiters) - (define channel (make-channel)) - (define destroy-condition - (make-condition)) - - (define pool - (make-resource-pool-record - name - channel - destroy-condition - `((delay-logger . ,delay-logger) - (duration-logger . ,duration-logger) - (scheduler . ,scheduler) - (name . ,name) - (default-checkout-timeout . ,default-checkout-timeout) - (default-max-waiters . ,default-max-waiters)))) - - (define checkout-failure-count 0) - - (define resources - (vector-map - (lambda (_ resource) - (make-resource-details - resource - 0 - #f)) - (if (vector? resources-list-or-vector) - resources-list-or-vector - (list->vector resources-list-or-vector)))) - - (define (destroy-loop) - (define (empty?) - (vector-every (lambda (r) - (eq? r #f)) - resources)) - - (let loop () - (match (get-message channel) - (('checkout reply timeout-time max-waiters) - (spawn-fiber - (lambda () - (let ((op - (put-operation - reply - (cons 'resource-pool-destroyed - #f)))) - (perform-operation - (if timeout-time - (choice-operation - op - (wrap-operation - (sleep-operation - (/ (- timeout-time - (get-internal-real-time)) - internal-time-units-per-second)) - (const #f))) - op))))) - (loop)) - (((and (or 'return - 'return-failed-checkout) - return-type) - resource-id) - (vector-set! resources - resource-id - #f) - - (if (empty?) - (begin - (set-resource-pool-channel! pool #f) - (signal-condition! destroy-condition) - - ;; No loop - *unspecified*) - (loop))) - - (('stats reply timeout-time) - (let ((stats - `((resources . ,(vector-length resources)) - (available . 0) - (waiters . 0) - (checkout-failure-count . ,checkout-failure-count)))) - - (spawn-fiber - (lambda () - (let ((op - (put-operation reply stats))) - (perform-operation - (if timeout-time - (choice-operation - op - (sleep-operation - (/ (- timeout-time - (get-internal-real-time)) - internal-time-units-per-second))) - op)))))) - - (loop)) - - (('destroy) - (loop)) - (unknown - (simple-format - (current-error-port) - "unrecognised message to ~A resource pool channel: ~A\n" - name - unknown) - (loop))))) - - (define (main-loop) - (let loop ((available (iota (vector-length resources))) - (waiters (make-q))) - - (match (get-message channel) - (('checkout reply timeout-time max-waiters) - (if (null? available) - (let ((waiters-count - (q-length waiters))) - (if (and max-waiters - (>= waiters-count - max-waiters)) - (begin - (spawn-fiber - (lambda () - (let ((op - (put-operation - reply - (cons 'too-many-waiters - waiters-count)))) - (perform-operation - (if timeout-time - (choice-operation - op - (wrap-operation - (sleep-operation - (/ (- timeout-time - (get-internal-real-time)) - internal-time-units-per-second)) - (const #f))) - op))))) - (loop available - waiters)) - (loop available - (enq! waiters (cons reply timeout-time))))) - - (if timeout-time - (let ((current-internal-time - (get-internal-real-time))) - ;; If this client is still waiting - (if (> timeout-time - current-internal-time) - (let ((reply-timeout - (/ (- timeout-time - current-internal-time) - internal-time-units-per-second)) - (resource-id - new-available - (car+cdr available))) - - ;; Don't sleep in this fiber, so spawn a new - ;; fiber to handle handing over the resource, - ;; and returning it if there's a timeout - (spawn-fiber-for-checkout - channel - reply - reply-timeout - resource-id - (resource-details-value - (vector-ref resources - resource-id))) - (loop new-available - waiters)) - (loop available - waiters))) - (let* ((resource-id - next-available - (car+cdr available)) - (resource-details - (vector-ref resources - resource-id))) - (put-message reply - (list 'success - resource-id - (resource-details-value - resource-details))) - - (loop next-available - waiters))))) - - (((and (or 'return - 'return-failed-checkout) - return-type) - resource-id) - - (when (eq? 'return-failed-checkout - return-type) - (set! checkout-failure-count - (+ 1 checkout-failure-count))) - - (let ((current-internal-time - (get-internal-real-time))) - (let waiter-loop ((waiter (safe-deq waiters))) - (match waiter - (#f - (loop (cons resource-id available) - waiters)) - ((reply . timeout) - (if (and timeout - (< timeout current-internal-time)) - (waiter-loop (safe-deq waiters)) - (if timeout - (let ((reply-timeout - (/ (- timeout - current-internal-time) - internal-time-units-per-second))) - ;; Don't sleep in this fiber, so spawn a - ;; new fiber to handle handing over the - ;; resource, and returning it if there's - ;; a timeout - (spawn-fiber-for-checkout - channel - reply - reply-timeout - resource-id - (resource-details-value - (vector-ref resources - resource-id)))) - (put-message reply - (list 'success - resource-id - (resource-details-value - (vector-ref resources - resource-id)))))) - (loop available - waiters)))))) - - (('list-resources reply) - (spawn-fiber - (lambda () - (put-message reply (vector->list resources)))) - - (loop available - waiters)) - - (('stats reply timeout-time) - (let ((stats - `((resources . ,(vector-length resources)) - (available . ,(length available)) - (waiters . ,(q-length waiters)) - (checkout-failure-count . ,checkout-failure-count)))) - - (spawn-fiber - (lambda () - (let ((op - (put-operation reply stats))) - (perform-operation - (if timeout-time - (choice-operation - op - (sleep-operation - (/ (- timeout-time - (get-internal-real-time)) - internal-time-units-per-second))) - op)))))) - - (loop available - waiters)) - - (('destroy) - (let ((current-internal-time (get-internal-real-time))) - ;; Notify all waiters that the pool has been destroyed - (for-each - (match-lambda - ((reply . timeout) - (when (or (not timeout) - (> timeout current-internal-time)) - (spawn-fiber - (lambda () - (let ((op - (put-operation - reply - (cons 'resource-pool-destroyed - #f)))) - (perform-operation - (if timeout - (choice-operation - op - (wrap-operation - (sleep-operation - (/ (- timeout - (get-internal-real-time)) - internal-time-units-per-second)) - (const #f))) - op)))))))) - (car waiters)) - - (if (= (vector-length resources) - (length available)) - (begin - (set-resource-pool-channel! pool #f) - (signal-condition! destroy-condition) - - ;; No loop - *unspecified*) - (destroy-loop)))) - - (unknown - (simple-format - (current-error-port) - "unrecognised message to ~A resource pool channel: ~A\n" - name - unknown) - (loop available - waiters))))) - - (spawn-fiber - (lambda () - (with-exception-handler - (lambda (exn) - #f) - (lambda () - (with-exception-handler - (lambda (exn) - (let* ((stack (make-stack #t)) - (error-string - (call-with-output-string - (lambda (port) - (display-backtrace stack port 3) - (simple-format - port - "exception in the ~A pool fiber, " name) - (print-exception - port - (stack-ref stack 3) - '%exception - (list exn)))))) - (display/knots error-string - (current-error-port))) - (raise-exception exn)) - (lambda () - (start-stack - #t - (main-loop))))) - #:unwind? #t)) - (or scheduler - (current-scheduler))) - - pool) - (define* (make-resource-pool return-new-resource max-size #:key (min-size 0) (idle-seconds #f) @@ -536,114 +126,105 @@ (define checkout-failure-count 0) - (define resources - (make-hash-table)) + (define spawn-fiber-to-return-new-resource + (if add-resources-parallelism + (let ((thunk + (fiberize + (lambda () + (let ((max-size + (assq-ref (resource-pool-configuration pool) + 'max-size)) + (size (assq-ref (resource-pool-stats pool) + 'resources))) + (unless (= size max-size) + (let ((new-resource + (return-new-resource))) + (put-message channel + (list 'add-resource new-resource)))))) + #:parallelism add-resources-parallelism))) + (lambda () + (spawn-fiber thunk))) + (lambda () + (spawn-fiber + (lambda () + (let ((new-resource + (with-exception-handler + (lambda _ #f) + (lambda () + (with-exception-handler + (lambda (exn) + (simple-format + (current-error-port) + "exception adding resource to pool ~A: ~A\n\n" + name + return-new-resource) + (print-backtrace-and-exception/knots exn) + (raise-exception exn)) + (lambda () + (start-stack #t (return-new-resource))))) + #:unwind? #t))) + (when new-resource + (put-message channel + (list 'add-resource new-resource))))))))) - (define-inlinable (count-resources resources) - (hash-count (const #t) resources)) - - (define return-new-resource/parallelism-limiter - (make-parallelism-limiter - (or add-resources-parallelism - max-size) - #:name - (string-append - name - " resource pool new resource parallelism limiter"))) - - (define (spawn-fiber-to-return-new-resource) - (spawn-fiber - (lambda () - (with-exception-handler - (lambda (exn) - ;; This can happen if the resource pool is destroyed very - ;; quickly - (if (resource-pool-destroyed-error? exn) - #f - (raise-exception exn))) - (lambda () - (let loop () - (let ((success? - (with-parallelism-limiter - return-new-resource/parallelism-limiter - (let ((max-size - (assq-ref (resource-pool-configuration pool) - 'max-size)) - (size (count-resources resources))) - (or (>= size max-size) - (with-exception-handler - (lambda _ #f) - (lambda () - (with-exception-handler - (lambda (exn) - (simple-format - (current-error-port) - "exception adding resource to pool ~A: ~A\n\n" - name - return-new-resource) - (print-backtrace-and-exception/knots exn) - (raise-exception exn)) - (lambda () - (let ((new-resource - (start-stack #t (return-new-resource)))) - (put-message channel - (list 'add-resource new-resource))) - #t))) - #:unwind? #t)))))) - (unless success? - ;; TODO Maybe this should be configurable? - (sleep 1) - - ;; Important to retry here and eventually create - ;; a new resource, as there might be waiters - ;; stuck waiting for a resource, especially if - ;; the pool is empty. - (loop))))) - #:unwind? #t)))) - - (define (spawn-fiber-to-destroy-resource resource-id resource-value) + (define (spawn-fiber-to-destroy-resource resource) (spawn-fiber (lambda () (let loop () - (let* ((success? - (with-exception-handler - (lambda _ #f) - (lambda () - (with-exception-handler - (lambda (exn) - (simple-format - (current-error-port) - "exception running resource pool destructor (~A): ~A\n" - name - destructor) - (print-backtrace-and-exception/knots exn) - (raise-exception exn)) - (lambda () - (start-stack #t (destructor resource-value)) - #t))) - #:unwind? #t))) + (let ((success? + (with-exception-handler + (lambda _ #f) + (lambda () + (with-exception-handler + (lambda (exn) + (simple-format + (current-error-port) + "exception running resource pool destructor (~A): ~A\n" + name + destructor) + (print-backtrace-and-exception/knots exn) + (raise-exception exn)) + (lambda () + (start-stack #t (destructor resource)) + #t))) + #:unwind? #t))) (if success? (put-message channel - (list 'remove resource-id)) + (list 'remove resource)) (begin (sleep 5) (loop)))))))) - (define (destroy-loop resources next-resource-id) - (let loop ((next-resource-id next-resource-id)) + (define (spawn-fiber-for-checkout reply-channel + reply-timeout + resource) + (spawn-fiber + (lambda () + (let ((checkout-success? + (perform-operation + (choice-operation + (wrap-operation + (put-operation reply-channel + (cons 'success resource)) + (const #t)) + (wrap-operation (sleep-operation + reply-timeout) + (const #f)))))) + (unless checkout-success? + (put-message + channel + (list 'return-failed-checkout resource))))))) + + (define (destroy-loop resources) + (let loop ((resources resources)) (match (get-message channel) (('add-resource resource) - (if destructor - (begin - (spawn-fiber-to-destroy-resource next-resource-id - resource) - (hash-set! resources next-resource-id resource) - - (loop (1+ next-resource-id))) - (loop next-resource-id))) + (when destructor + (spawn-fiber-to-destroy-resource resource)) + (loop resources)) (('checkout reply timeout-time max-waiters) (spawn-fiber (lambda () @@ -663,142 +244,154 @@ internal-time-units-per-second)) (const #f))) op))))) - (loop next-resource-id)) + (loop resources)) (((and (or 'return 'return-failed-checkout 'remove) return-type) - resource-id) - (when (and (not (eq? return-type 'remove)) - destructor) - (spawn-fiber-to-destroy-resource - resource-id - (resource-details-value - (hash-ref resources resource-id)))) + resource) + (when destructor + (spawn-fiber-to-destroy-resource resource)) - (hash-remove! resources resource-id) + (let ((index + (list-index (lambda (x) + (eq? x resource)) + resources))) + (define (remove-at-index! lst i) + (let ((start + end + (split-at! lst i))) + (append + start + (cdr end)))) - (if (= 0 (count-resources resources)) - (begin - (set-resource-pool-channel! pool #f) - (signal-condition! destroy-condition) + (let ((new-resources + (if index + (remove-at-index! resources index) + (begin + (simple-format + (current-error-port) + "resource pool error: unable to remove ~A\n" + resource) + resources)))) + (if (null? new-resources) + (begin + (signal-condition! destroy-condition) - ;; No loop - *unspecified*) - (loop next-resource-id))) - (('stats reply timeout-time) + ;; No loop + *unspecified*) + (loop new-resources))))) + + (('stats reply) (let ((stats - `((resources . ,(count-resources resources)) + `((resources . ,(length resources)) (available . 0) (waiters . 0) (checkout-failure-count . ,checkout-failure-count)))) (spawn-fiber (lambda () - (let ((op - (put-operation reply stats))) - (perform-operation - (if timeout-time - (choice-operation - op - (sleep-operation - (/ (- timeout-time - (get-internal-real-time)) - internal-time-units-per-second))) - op)))))) + (perform-operation + (choice-operation + (wrap-operation + (put-operation reply stats) + (const #t)) + (wrap-operation (sleep-operation 5) + (const #f))))))) - (loop next-resource-id)) + (loop resources)) (('check-for-idle-resources) - (loop next-resource-id)) + (loop resources)) - (('destroy) - (loop next-resource-id)) + (('destroy reply) + (loop resources)) (unknown (simple-format (current-error-port) "unrecognised message to ~A resource pool channel: ~A\n" name unknown) - (loop next-resource-id))))) + (loop resources))))) (define (main-loop) - (let loop ((next-resource-id 0) + (let loop ((resources '()) (available '()) - (waiters (make-q))) + (waiters '()) + (resources-last-used '())) (match (get-message channel) (('add-resource resource) - (if (= (count-resources resources) max-size) - (if destructor - (begin - (hash-set! resources - next-resource-id - (make-resource-details - resource - 0 - (get-internal-real-time))) - (spawn-fiber-to-destroy-resource next-resource-id - resource) + (if (= (length resources) max-size) + (begin + (if destructor + (begin + (spawn-fiber-to-destroy-resource resource) - (loop (1+ next-resource-id) + (loop (cons resource resources) + available + waiters + (cons (get-internal-real-time) + resources-last-used))) + (loop resources available - waiters)) - (loop next-resource-id - available - waiters)) + waiters + (cons (get-internal-real-time) + resources-last-used)))) - (let* ((current-internal-time - (get-internal-real-time)) - (resource-details - (make-resource-details - resource - 0 - current-internal-time))) - (hash-set! resources - next-resource-id - resource-details) - (let waiter-loop ((waiter (safe-deq waiters))) - (match waiter - (#f - (loop (1+ next-resource-id) - (cons next-resource-id available) - waiters)) - ((reply . timeout) - (if (and timeout - (< timeout current-internal-time)) - (waiter-loop (safe-deq waiters)) - (if timeout - (let ((reply-timeout - (/ (- timeout - current-internal-time) - internal-time-units-per-second))) - ;; Don't sleep in this fiber, so spawn a - ;; new fiber to handle handing over the - ;; resource, and returning it if there's - ;; a timeout - (spawn-fiber-for-checkout channel - reply - reply-timeout - next-resource-id - resource)) - (put-message reply (list 'success - next-resource-id - resource)))) - (set-resource-details-checkout-count! resource-details - 1) - (loop (1+ next-resource-id) - available - waiters))))))) + (if (null? waiters) + (loop (cons resource resources) + (cons resource available) + waiters + (cons (get-internal-real-time) + resources-last-used)) + + (let* ((current-internal-time (get-internal-real-time)) + (alive-waiters + dead-waiters + (partition! + (match-lambda + ((reply . timeout) + (or (not timeout) + (> timeout current-internal-time)))) + waiters))) + (if (null? alive-waiters) + (loop (cons resource resources) + (cons resource available) + '() + (cons (get-internal-real-time) + resources-last-used)) + (match (last alive-waiters) + ((waiter-channel . waiter-timeout) + (if waiter-timeout + (let ((reply-timeout + (/ (- waiter-timeout + current-internal-time) + internal-time-units-per-second))) + ;; Don't sleep in this fiber, so spawn + ;; a new fiber to handle handing over + ;; the resource, and returning it if + ;; there's a timeout + (spawn-fiber-for-checkout waiter-channel + reply-timeout + resource)) + (put-message waiter-channel (cons 'success + resource))) + + (loop (cons resource resources) + available + (drop-right! alive-waiters 1) + (cons (get-internal-real-time) + resources-last-used))))))))) (('checkout reply timeout-time max-waiters) (if (null? available) (begin - (unless (= (count-resources resources) max-size) + (unless (= (length resources) max-size) (spawn-fiber-to-return-new-resource)) (let ((waiters-count - (q-length waiters))) + (length waiters))) (if (and max-waiters (>= waiters-count max-waiters)) @@ -821,12 +414,15 @@ internal-time-units-per-second)) (const #f))) op))))) - (loop next-resource-id + (loop resources available - waiters)) - (loop next-resource-id + waiters + resources-last-used)) + (loop resources available - (enq! waiters (cons reply timeout-time)))))) + (cons (cons reply timeout-time) + waiters) + resources-last-used)))) (if timeout-time (let ((current-internal-time @@ -834,283 +430,260 @@ ;; If this client is still waiting (if (> timeout-time current-internal-time) - (let* ((reply-timeout - (/ (- timeout-time - current-internal-time) - internal-time-units-per-second)) - (resource-id - (car available)) - (resource-details - (hash-ref resources resource-id))) - - (increment-resource-checkout-count! - resource-details) + (let ((reply-timeout + (/ (- timeout-time + current-internal-time) + internal-time-units-per-second))) ;; Don't sleep in this fiber, so spawn a new ;; fiber to handle handing over the resource, ;; and returning it if there's a timeout - (spawn-fiber-for-checkout channel - reply + (spawn-fiber-for-checkout reply reply-timeout - resource-id - (resource-details-value - resource-details)) - (loop next-resource-id + (car available)) + (loop resources (cdr available) - waiters)) - (loop next-resource-id + waiters + resources-last-used)) + (loop resources available - waiters))) - (let* ((resource-id - next-available - (car+cdr available)) - (resource-details - (hash-ref resources - resource-id))) - (increment-resource-checkout-count! resource-details) + waiters + resources-last-used))) + (begin + (put-message reply (cons 'success + (car available))) - (put-message reply - (list 'success - resource-id - (resource-details-value - resource-details))) - - (loop next-resource-id - next-available - waiters))))) + (loop resources + (cdr available) + waiters + resources-last-used))))) (((and (or 'return 'return-failed-checkout) return-type) - resource-id) + resource) (when (eq? 'return-failed-checkout return-type) (set! checkout-failure-count (+ 1 checkout-failure-count))) - (let ((current-internal-time - (get-internal-real-time)) - (resource-details - (hash-ref resources resource-id))) - (if (and lifetime - (>= (resource-details-checkout-count resource-details) - lifetime)) - (begin - (spawn-fiber-to-destroy-resource resource-id - (resource-details-value - resource-details)) - (loop next-resource-id - available - waiters)) - (let waiter-loop ((waiter (safe-deq waiters))) - (match waiter - (#f - (if (eq? 'return-failed-checkout - return-type) - (decrement-resource-checkout-count! resource-details) - (set-resource-details-last-used! - resource-details - current-internal-time)) + (if (null? waiters) + (loop resources + (cons resource available) + waiters + (begin + (list-set! + resources-last-used + (list-index (lambda (x) + (eq? x resource)) + resources) + (get-internal-real-time)) + resources-last-used)) - (loop next-resource-id - (cons resource-id available) - waiters)) - ((reply . timeout) - (if (and timeout - (< timeout current-internal-time)) - (waiter-loop (safe-deq waiters)) - (if timeout - (let ((reply-timeout - (/ (- timeout - current-internal-time) - internal-time-units-per-second))) - ;; Don't sleep in this fiber, so spawn a - ;; new fiber to handle handing over the - ;; resource, and returning it if there's - ;; a timeout - (spawn-fiber-for-checkout - channel - reply - reply-timeout - resource-id - (resource-details-value resource-details))) - (put-message reply - (list 'success - resource-id - (resource-details-value - resource-details))))) + (let* ((current-internal-time (get-internal-real-time)) + (alive-waiters + dead-waiters + (partition! + (match-lambda + ((reply . timeout) + (or (not timeout) + (> timeout current-internal-time)))) + waiters))) + (if (null? alive-waiters) + (loop resources + (cons resource available) + '() + (begin + (when (eq? return-type 'return) + (list-set! + resources-last-used + (list-index (lambda (x) + (eq? x resource)) + resources) + (get-internal-real-time))) + resources-last-used)) + (match (last alive-waiters) + ((waiter-channel . waiter-timeout) + (if waiter-timeout + (let ((reply-timeout + (/ (- waiter-timeout + current-internal-time) + internal-time-units-per-second))) + ;; Don't sleep in this fiber, so spawn a + ;; new fiber to handle handing over the + ;; resource, and returning it if there's a + ;; timeout + (spawn-fiber-for-checkout waiter-channel + reply-timeout + resource)) + (put-message waiter-channel (cons 'success + resource))) - (set-resource-details-last-used! resource-details - current-internal-time) - (when (eq? 'return-failed-checkout - return-type) - (decrement-resource-checkout-count! resource-details)) + (loop resources + available + (drop-right! alive-waiters 1) + (begin + (list-set! + resources-last-used + (list-index (lambda (x) + (eq? x resource)) + resources) + (get-internal-real-time)) + resources-last-used)))))))) - (loop next-resource-id - available - waiters))))))) + (('remove resource) + (let ((index + (list-index (lambda (x) + (eq? x resource)) + resources))) + (define (remove-at-index! lst i) + (let ((start + end + (split-at! lst i))) + (append + start + (cdr end)))) - (('remove resource-id) - (hash-remove! resources - resource-id) + (loop (if index + (remove-at-index! resources index) + (begin + (simple-format + (current-error-port) + "resource pool error: unable to remove ~A\n" + resource) + resources)) + available ; resource shouldn't be in this list + waiters + (remove-at-index! + resources-last-used + index)))) - (when (and (not (q-empty? waiters)) - (< (- (count-resources resources) 1) - max-size)) - (spawn-fiber-to-return-new-resource)) + (('destroy resource) + (spawn-fiber-to-destroy-resource resource) - (loop next-resource-id - available ; resource shouldn't be in this list - waiters)) - - (('destroy resource-id) - (let ((resource-details - (hash-ref resources - resource-id))) - (spawn-fiber-to-destroy-resource resource-id - (resource-details-value - resource-details)) - - (loop next-resource-id - available - waiters))) + (loop resources + available + waiters + resources-last-used)) (('list-resources reply) (spawn-fiber (lambda () - (put-message reply (hash-map->list - (lambda (_ value) value) - resources)))) + (put-message reply (list-copy resources)))) - (loop next-resource-id + (loop resources available - waiters)) + waiters + resources-last-used)) - (('stats reply timeout-time) + (('stats reply) (let ((stats - `((resources . ,(count-resources resources)) + `((resources . ,(length resources)) (available . ,(length available)) - (waiters . ,(q-length waiters)) - (resources-checkout-count - . ,(hash-fold - (lambda (_ resource-details result) - (cons (resource-details-checkout-count - resource-details) - result)) - '() - resources)) + (waiters . ,(length waiters)) (checkout-failure-count . ,checkout-failure-count)))) (spawn-fiber (lambda () - (let ((op - (put-operation reply stats))) - (perform-operation - (if timeout-time - (choice-operation - op - (sleep-operation - (/ (- timeout-time - (get-internal-real-time)) - internal-time-units-per-second))) - op)))))) + (perform-operation + (choice-operation + (wrap-operation + (put-operation reply stats) + (const #t)) + (wrap-operation (sleep-operation 5) + (const #f))))))) - (loop next-resource-id + (loop resources available - waiters)) + waiters + resources-last-used)) (('check-for-idle-resources) - (let* ((internal-real-time - (get-internal-real-time)) - (candidate-resource-ids-to-destroy + (let* ((resources-last-used-seconds + (map + (lambda (internal-time) + (/ (- (get-internal-real-time) internal-time) + internal-time-units-per-second)) + resources-last-used)) + (candidate-resources-to-destroy (filter-map - (lambda (resource-id) - (let ((resource-details - (hash-ref resources resource-id))) - (if (> (/ (- internal-real-time - (resource-details-last-used - resource-details)) - internal-time-units-per-second) - idle-seconds) - resource-id - #f))) - available)) - (max-resources-to-destroy - (max 0 - (- (count-resources resources) - min-size))) - (resources-to-destroy - (take candidate-resource-ids-to-destroy - (min max-resources-to-destroy - (length candidate-resource-ids-to-destroy))))) - (when destructor - (for-each - (lambda (resource-id) - (spawn-fiber-to-destroy-resource - resource-id - (resource-details-value - (hash-ref resources resource-id)))) - resources-to-destroy)) + (lambda (resource last-used-seconds) + (if (and (member resource available) + (> last-used-seconds idle-seconds)) + resource + #f)) + resources + resources-last-used-seconds))) - (loop next-resource-id - (lset-difference = available resources-to-destroy) - waiters))) + (let* ((available-resources-to-destroy + (lset-intersection eq? + available + candidate-resources-to-destroy)) + (max-resources-to-destroy + (max 0 + (- (length resources) + min-size))) + (resources-to-destroy + (take available-resources-to-destroy + (min max-resources-to-destroy + (length available-resources-to-destroy))))) + (when destructor + (for-each + (lambda (resource) + (spawn-fiber-to-destroy-resource resource)) + resources-to-destroy)) + + (loop resources + (lset-difference eq? available resources-to-destroy) + waiters + resources-last-used)))) (('destroy) - (let ((current-internal-time (get-internal-real-time))) - (for-each - (match-lambda - ((reply . timeout) - (when (or (not timeout) - (> timeout current-internal-time)) - (spawn-fiber - (lambda () - (let ((op - (put-operation - reply - (cons 'resource-pool-destroyed - #f)))) - (perform-operation - (if timeout - (choice-operation - op - (wrap-operation - (sleep-operation - (/ (- timeout - (get-internal-real-time)) - internal-time-units-per-second)) - (const #f))) - op)))))))) - (car waiters)) + (if (and (null? resources) + (null? waiters)) + (signal-condition! + destroy-condition) - (when destructor - (for-each - (lambda (resource-id) - (spawn-fiber-to-destroy-resource - resource-id - (resource-details-value - (hash-ref resources - resource-id)))) - available)) + (begin + (for-each + (lambda (resource) + (if destructor + (spawn-fiber-to-destroy-resource resource) + (spawn-fiber + (lambda () + (put-message channel + (list 'remove resource))) + #:parallel? #t))) + available) - ;; Do this in parallel to avoid deadlocks between the - ;; limiter and returning new resources to this pool - (and=> return-new-resource/parallelism-limiter - (lambda (limiter) - (spawn-fiber - (lambda () - (destroy-parallelism-limiter limiter))))) + (let ((current-internal-time (get-internal-real-time))) + (for-each + (match-lambda + ((reply . timeout) + (when (or (not timeout) + (> timeout current-internal-time)) + (spawn-fiber + (lambda () + (let ((op + (put-operation + reply + (cons 'resource-pool-destroyed + #f)))) + (perform-operation + (if timeout + (choice-operation + op + (wrap-operation + (sleep-operation + (/ (- timeout + (get-internal-real-time)) + internal-time-units-per-second)) + (const #f))) + op)))))))) + waiters)) - (if (or (= 0 (count-resources resources)) - (not destructor)) - (begin - (set-resource-pool-channel! pool #f) - (signal-condition! destroy-condition) - - ;; No loop - *unspecified*) - (destroy-loop resources next-resource-id)))) + (destroy-loop resources)))) (unknown (simple-format @@ -1118,26 +691,19 @@ "unrecognised message to ~A resource pool channel: ~A\n" name unknown) - (loop next-resource-id + (loop resources available - waiters))))) + waiters + resources-last-used))))) (spawn-fiber (lambda () (when idle-seconds (spawn-fiber (lambda () - (let loop () - (put-message channel '(check-for-idle-resources)) - (when (perform-operation - (choice-operation - (wrap-operation - (sleep-operation idle-seconds) - (const #t)) - (wrap-operation - (wait-operation destroy-condition) - (const #f)))) - (loop)))))) + (while #t + (sleep idle-seconds) + (put-message channel '(check-for-idle-resources)))))) (with-exception-handler (lambda (exn) @@ -1158,8 +724,8 @@ (stack-ref stack 3) '%exception (list exn)))))) - (display/knots error-string - (current-error-port))) + (display error-string + (current-error-port))) (raise-exception exn)) (lambda () (start-stack @@ -1178,8 +744,7 @@ (put-operation (resource-pool-channel pool) (list 'destroy)) (lambda _ - (wait - (resource-pool-destroy-condition pool)))) + (wait (resource-pool-destroy-condition pool)))) (wait-operation (resource-pool-destroy-condition pool)))) #t) @@ -1198,7 +763,7 @@ (record-constructor &resource-pool-timeout)) (define resource-pool-timeout-error? - (exception-predicate &resource-pool-timeout)) + (record-predicate &resource-pool-timeout)) (define &resource-pool-too-many-waiters (make-exception-type '&recource-pool-too-many-waiters @@ -1219,7 +784,7 @@ (record-constructor &resource-pool-too-many-waiters)) (define resource-pool-too-many-waiters-error? - (exception-predicate &resource-pool-too-many-waiters)) + (record-predicate &resource-pool-too-many-waiters)) (define &resource-pool-destroyed (make-exception-type '&recource-pool-destroyed @@ -1235,7 +800,7 @@ (record-constructor &resource-pool-destroyed)) (define resource-pool-destroyed-error? - (exception-predicate &resource-pool-destroyed)) + (record-predicate &resource-pool-destroyed)) (define &resource-pool-destroy-resource (make-exception-type '&recource-pool-destroy-resource @@ -1246,7 +811,7 @@ (record-constructor &resource-pool-destroy-resource)) (define resource-pool-destroy-resource-exception? - (exception-predicate &resource-pool-destroy-resource)) + (record-predicate &resource-pool-destroy-resource)) (define resource-pool-default-timeout-handler (make-parameter #f)) @@ -1272,10 +837,6 @@ available. Return the resource once PROC has returned." 'default-max-waiters) max-waiters)) - (unless channel - (raise-exception - (make-resource-pool-destroyed-error pool))) - (let ((reply (if timeout-or-default (let loop ((reply (make-channel)) @@ -1318,9 +879,8 @@ available. Return the resource once PROC has returned." start-time) 'timeout) response)) - 'timeout)) - 'timeout))) - (let ((reply (make-channel))) + 'timeout))))) + (let loop ((reply (make-channel))) (put-message channel (list 'checkout reply @@ -1343,7 +903,7 @@ available. Return the resource once PROC has returned." (('resource-pool-destroyed . #f) (raise-exception (make-resource-pool-destroyed-error pool))) - (('success resource-id resource-value) + (('success . resource) (call-with-values (lambda () (with-exception-handler @@ -1352,13 +912,14 @@ available. Return the resource once PROC has returned." ;; this avoids inconsistent behaviour with ;; continuation barriers (put-message - channel + (resource-pool-channel pool) (list (if (or destroy-resource-on-exception? (resource-pool-destroy-resource-exception? exn)) 'destroy 'return) - resource-id)) - (raise-exception exn)) + resource)) + (unless (resource-pool-destroy-resource-exception? exn) + (raise-exception exn))) (lambda () (with-exception-handler (lambda (exn) @@ -1375,11 +936,11 @@ available. Return the resource once PROC has returned." exn (make-knots-exception stack))))) (lambda () - (proc resource-value)))) + (proc resource)))) #:unwind? #t)) (lambda vals - (put-message channel - `(return ,resource-id)) + (put-message (resource-pool-channel pool) + `(return ,resource)) (apply values vals))))))) (define-syntax-rule (with-resource-from-pool pool resource exp ...) @@ -1388,58 +949,36 @@ available. Return the resource once PROC has returned." (lambda (resource) exp ...))) (define* (resource-pool-stats pool #:key (timeout 5)) - (define channel - (resource-pool-channel pool)) + (let ((reply (make-channel)) + (start-time (get-internal-real-time))) + (perform-operation + (choice-operation + (wrap-operation + (put-operation (resource-pool-channel pool) + `(stats ,reply)) + (const #t)) + (wrap-operation (sleep-operation timeout) + (lambda _ + (raise-exception + (make-resource-pool-timeout-error pool)))))) - (unless channel - (raise-exception - (make-resource-pool-destroyed-error pool))) - - (if timeout - (let* ((reply (make-channel)) - (start-time (get-internal-real-time)) - (timeout-time - (+ start-time - (* internal-time-units-per-second timeout)))) - (perform-operation - (choice-operation - (wrap-operation - (put-operation channel - `(stats ,reply ,timeout-time)) - (const #t)) - (wrap-operation (sleep-operation timeout) - (lambda _ - (raise-exception - (make-resource-pool-timeout-error pool)))))) - - (let ((time-remaining - (- timeout - (/ (- (get-internal-real-time) - start-time) - internal-time-units-per-second)))) - (if (> time-remaining 0) - (perform-operation - (choice-operation - (get-operation reply) - (wrap-operation (sleep-operation time-remaining) - (lambda _ - (raise-exception - (make-resource-pool-timeout-error pool)))))) - (raise-exception - (make-resource-pool-timeout-error pool))))) - (let ((reply (make-channel))) - (put-message channel - `(stats ,reply #f)) - (get-message reply)))) + (let ((time-remaining + (- timeout + (/ (- (get-internal-real-time) + start-time) + internal-time-units-per-second)))) + (if (> time-remaining 0) + (perform-operation + (choice-operation + (get-operation reply) + (wrap-operation (sleep-operation time-remaining) + (lambda _ + (raise-exception + (make-resource-pool-timeout-error pool)))))) + (raise-exception + (make-resource-pool-timeout-error pool)))))) (define (resource-pool-list-resources pool) - (define channel - (resource-pool-channel pool)) - - (unless channel - (raise-exception - (make-resource-pool-destroyed-error pool))) - (let ((reply (make-channel))) (put-message (resource-pool-channel pool) (list 'list-resources reply)) diff --git a/knots/sort.scm b/knots/sort.scm deleted file mode 100644 index dcad052..0000000 --- a/knots/sort.scm +++ /dev/null @@ -1,88 +0,0 @@ -;;; Guile Knots -;;; Copyright © 2020, 2025 Christopher Baines -;;; -;;; This file is part of Guile Knots. -;;; -;;; The Guile Knots is free software; you can redistribute it and/or -;;; modify it under the terms of the GNU General Public License as -;;; published by the Free Software Foundation; either version 3 of the -;;; License, or (at your option) any later version. -;;; -;;; The Guile Knots is distributed in the hope that it will be useful, -;;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -;;; General Public License for more details. -;;; -;;; You should have received a copy of the GNU General Public License -;;; along with the guix-data-service. If not, see -;;; . - -(define-module (knots sort) - #:use-module (srfi srfi-1) - #:use-module (srfi srfi-71) - #:use-module (ice-9 match) - #:use-module (fibers scheduler) - #:use-module (knots promise) - #:export (fibers-sort!)) - -(define (try-split-at! lst i) - (cond ((< i 0) - (error "negitive split size")) - ((= i 0) - (values '() lst)) - (else - (let lp ((l lst) (n (- i 1))) - (if (<= n 0) - (let ((tmp (cdr l))) - (unless (null? tmp) - (set-cdr! l '())) - (values lst tmp)) - (if (or (null? l) - (null? (cdr l))) - (values lst '()) - (lp (cdr l) (- n 1)))))))) - -(define (chunk! lst max-length) - (let loop ((chunks '()) - (lst lst)) - (let ((chunk - rest - (try-split-at! lst max-length))) - (if (null? rest) - (reverse! (cons chunk chunks)) - (loop (cons chunk chunks) - rest))))) - -(define* (fibers-sort! items less #:key parallelism) - (define requested-chunk-count - (or parallelism - (+ 1 (length (scheduler-remote-peers (current-scheduler)))))) - - (define items-length (length items)) - - (if (= 0 items-length) - items - (let* ((chunk-length (ceiling (/ items-length - requested-chunk-count))) - (chunks (chunk! items chunk-length))) - (let loop ((sorted-chunk-promises - (map - (lambda (chunk) - (fibers-delay/eager - (lambda () - (sort! chunk less)))) - chunks))) - (if (null? (cdr sorted-chunk-promises)) - (fibers-force - (first sorted-chunk-promises)) - (loop - (map - (match-lambda - ((items) items) - ((a b) - (fibers-delay/eager - (lambda () - (merge! (fibers-force a) - (fibers-force b) - less))))) - (chunk! sorted-chunk-promises 2)))))))) diff --git a/knots/thread-pool.scm b/knots/thread-pool.scm index 22c1b5c..b176162 100644 --- a/knots/thread-pool.scm +++ b/knots/thread-pool.scm @@ -198,7 +198,7 @@ from there, or #f if that would be an empty string." (record-accessor &thread-pool-timeout-error 'pool))) (define thread-pool-timeout-error? - (exception-predicate &thread-pool-timeout-error)) + (record-predicate &thread-pool-timeout-error)) (define* (make-fixed-size-thread-pool size #:key @@ -269,8 +269,8 @@ from there, or #f if that would be an empty string." (sleep 1) (destructor/safe args))))) - (define (process thread-index channel args) - (let loop ((lifetime thread-lifetime)) + (define (process channel args) + (let loop () (match (get-message channel) ('destroy #f) ((reply sent-time proc) @@ -292,9 +292,6 @@ from there, or #f if that would be an empty string." internal-time-units-per-second) exn)) (lambda () - (vector-set! thread-proc-vector - thread-index - proc) (with-exception-handler (lambda (exn) (let ((stack @@ -322,10 +319,6 @@ from there, or #f if that would be an empty string." vals)))))) #:unwind? #t))) - (vector-set! thread-proc-vector - thread-index - #f) - (put-message reply response) @@ -342,11 +335,7 @@ from there, or #f if that would be an empty string." (if (and exception? expire-on-exception?) #t - (if lifetime - (if (<= lifetime 1) - #t - (loop (- lifetime 1))) - (loop lifetime))))))))) + (loop)))))))) (define (start-thread index channel) (call-with-new-thread @@ -369,7 +358,7 @@ from there, or #f if that would be an empty string." "knots: thread-pool: internal exception: ~A\n" exn)) (lambda () (parameterize ((param args)) - (process index channel args))) + (process channel args))) #:unwind? #t))) (when thread-destructor @@ -406,8 +395,7 @@ from there, or #f if that would be an empty string." (expire-on-exception? #f) (name "unnamed") (use-default-io-waiters? #t) - default-checkout-timeout - default-max-waiters) + default-checkout-timeout) "Return a channel used to offload work to a dedicated thread. ARGS are the arguments of the thread pool procedure." (define param @@ -420,6 +408,7 @@ arguments of the thread pool procedure." 1 #:thread-initializer thread-initializer #:thread-destructor thread-destructor + #:thread-lifetime thread-lifetime #:expire-on-exception? expire-on-exception? #:name name #:use-default-io-waiters? use-default-io-waiters?)) @@ -427,11 +416,9 @@ arguments of the thread pool procedure." #:destructor destroy-thread-pool #:min-size min-size #:delay-logger delay-logger - #:lifetime thread-lifetime #:scheduler scheduler #:duration-logger duration-logger - #:default-checkout-timeout default-checkout-timeout - #:default-max-waiters default-max-waiters))) + #:default-checkout-timeout default-checkout-timeout))) (thread-pool resource-pool param))) diff --git a/knots/timeout.scm b/knots/timeout.scm index a65a095..58306e0 100644 --- a/knots/timeout.scm +++ b/knots/timeout.scm @@ -85,7 +85,7 @@ (record-constructor &port-timeout-error)) (define port-timeout-error? - (exception-predicate &port-timeout-error)) + (record-predicate &port-timeout-error)) (define &port-read-timeout-error (make-exception-type '&port-read-timeout-error @@ -96,7 +96,7 @@ (record-constructor &port-read-timeout-error)) (define port-read-timeout-error? - (exception-predicate &port-read-timeout-error)) + (record-predicate &port-read-timeout-error)) (define &port-write-timeout-error (make-exception-type '&port-write-timeout-error @@ -107,7 +107,7 @@ (record-constructor &port-write-timeout-error)) (define port-write-timeout-error? - (exception-predicate &port-write-timeout-error)) + (record-predicate &port-write-timeout-error)) (define (readable? port) "Test if PORT is writable." diff --git a/knots/web-server.scm b/knots/web-server.scm index adaba13..453db44 100644 --- a/knots/web-server.scm +++ b/knots/web-server.scm @@ -63,14 +63,6 @@ (bind sock family addr port) sock)) -(define crlf-bv - (string->utf8 "\r\n")) - -(define (chunked-output-port-overhead-bytes write-size) - (+ (string-length (number->string write-size 16)) - (bytevector-length crlf-bv) - (bytevector-length crlf-bv))) - (define* (make-chunked-output-port/knots port #:key (keep-alive? #f) (buffering 1200)) "Returns a new port which translates non-encoded data into a HTTP @@ -82,12 +74,10 @@ when done, as it will output the remaining data, and encode the final zero chunk. When the port is closed it will also close PORT, unless KEEP-ALIVE? is true." (define (write! bv start count) - (let ((len-string - (number->string count 16))) - (put-string port len-string)) - (put-bytevector port crlf-bv 0 2) + (put-string port (number->string count 16)) + (put-string port "\r\n") (put-bytevector port bv start count) - (put-bytevector port crlf-bv 0 2) + (put-string port "\r\n") (force-output port) count) @@ -140,7 +130,7 @@ closes PORT, unless KEEP-ALIVE? is true." (record-constructor &request-body-ended-prematurely)) (define request-body-ended-prematurely-error? - (exception-predicate &request-body-ended-prematurely)) + (record-predicate &request-body-ended-prematurely)) (define (request-body-port/knots r) (cond @@ -228,6 +218,8 @@ on the procedure being called at any particular time." (adapt-response-version response (request-version request)) body)) + ((not body) + (values response #vu8())) ((string? body) (let* ((type (response-content-type response '(text/plain))) @@ -241,15 +233,16 @@ on the procedure being called at any particular time." `(,@type (charset . ,charset)))) (string->bytevector body charset)))) ((not (or (bytevector? body) - (procedure? body) - (eq? #f body))) + (procedure? body))) (raise-exception (make-exception-with-irritants (list (make-exception-with-message "unexpected body type") body)))) ((and (response-must-not-include-body? response) - body) + body + ;; FIXME make this stricter: even an empty body should be prohibited. + (not (zero? (bytevector-length body)))) (raise-exception (make-exception-with-irritants (list (make-exception-with-message @@ -259,24 +252,25 @@ on the procedure being called at any particular time." ;; check length; assert type; add other required fields? (values (response-maybe-add-connection-header-value request - (cond - ((procedure? body) - (if (response-content-length response) - response - (extend-response response - 'transfer-encoding - '((chunked))))) - ((bytevector? body) - (let ((rlen (response-content-length response)) - (blen (bytevector-length body))) - (cond - (rlen (if (= rlen blen) - response - (error "bad content-length" rlen blen))) - (else (extend-response response 'content-length blen))))) - (else response))) + (if (procedure? body) + (if (response-content-length response) + response + (extend-response response + 'transfer-encoding + '((chunked)))) + (let ((rlen (response-content-length response)) + (blen (bytevector-length body))) + (cond + (rlen (if (= rlen blen) + response + (error "bad content-length" rlen blen))) + (else (extend-response response 'content-length blen)))))) (if (eq? (request-method request) 'HEAD) - #f + (raise-exception + (make-exception-with-irritants + (list (make-exception-with-message + "unexpected body type") + body))) body))))) (define (with-stack-and-prompt thunk) @@ -289,7 +283,7 @@ on the procedure being called at any particular time." (not (memq 'close (response-connection response)))) (define (default-read-request-exception-handler exn) - (display/knots "While reading request:\n" (current-error-port)) + (display "While reading request:\n" (current-error-port)) (print-exception (current-error-port) #f @@ -302,12 +296,12 @@ on the procedure being called at any particular time." (if (and (exception-with-origin? exn) (string=? (exception-origin exn) "fport_write")) - (simple-format/knots + (simple-format (current-error-port) "~A ~A: error replying to client\n" (request-method request) (uri-path (request-uri request))) - (simple-format/knots + (simple-format (current-error-port) "knots web server: ~A ~A: exception replying to client: ~A\n" (request-method request) @@ -329,27 +323,23 @@ on the procedure being called at any particular time." (print-backtrace-and-exception/knots exn #:port port))))) - (display/knots error-string - (current-error-port))) + (display error-string + (current-error-port))) (values (build-response #:code 500) ;; TODO Make this configurable (string->utf8 "internal server error"))) -(define* (handle-request handler client - read-request-exception-handler - write-response-exception-handler - buffer-size - #:key post-request-hook) +(define (handle-request handler client + read-request-exception-handler + write-response-exception-handler) (let ((request (with-exception-handler read-request-exception-handler (lambda () (read-request client)) - #:unwind? #t)) - (read-request-time - (get-internal-real-time))) + #:unwind? #t))) (let ((response body (cond @@ -398,59 +388,41 @@ on the procedure being called at any particular time." (lambda () (write-response response client) - (let ((response-start-time - (get-internal-real-time)) - (body-written? - (cond - ((and (procedure? body) - (not - (eq? (request-method request) - 'HEAD))) - (let* ((type (response-content-type response - '(text/plain))) - (declared-charset (assq-ref (cdr type) 'charset)) - (charset (or declared-charset "ISO-8859-1")) - (body-port - (if (response-content-length response) - client - (make-chunked-output-port/knots - client - #:keep-alive? #t - #:buffering - (- buffer-size - (chunked-output-port-overhead-bytes - buffer-size)))))) - (set-port-encoding! body-port charset) - (let ((body-written? - (with-exception-handler - (lambda (exn) - #f) - (lambda () - (with-exception-handler - (lambda (exn) - (print-backtrace-and-exception/knots exn) - (raise-exception exn)) - (lambda () - (body body-port))) - #t) - #:unwind? #t))) - (unless (response-content-length response) - (close-port body-port)) - body-written?))) - ((bytevector? body) - (put-bytevector client body) - #t) - (else - ;; No body to write - #t)))) + (let ((body-written? + (if (procedure? body) + (let* ((type (response-content-type response + '(text/plain))) + (declared-charset (assq-ref (cdr type) 'charset)) + (charset (or declared-charset "ISO-8859-1")) + (body-port + (if (response-content-length response) + client + (make-chunked-output-port/knots + client + #:keep-alive? #t)))) + (set-port-encoding! body-port charset) + (let ((body-written? + (with-exception-handler + (lambda (exn) + #f) + (lambda () + (with-exception-handler + (lambda (exn) + (print-backtrace-and-exception/knots exn) + (raise-exception exn)) + (lambda () + (body body-port))) + #t) + #:unwind? #t))) + (unless (response-content-length response) + (close-port body-port)) + body-written?)) + (begin + (put-bytevector client body) + #t)))) (if body-written? (begin (force-output client) - (when post-request-hook - (post-request-hook request - #:read-request-time read-request-time - #:response-start-time response-start-time - #:response-end-time (get-internal-real-time))) (when (and (procedure? body) (response-content-length response)) (set-port-encoding! client "ISO-8859-1")) @@ -462,8 +434,7 @@ on the procedure being called at any particular time." read-request-exception-handler write-response-exception-handler connection-idle-timeout - buffer-size - post-request-hook) + buffer-size) ;; Always disable Nagle's algorithm, as we handle buffering ;; ourselves; when we force-output, we really want the data to go ;; out. @@ -476,17 +447,13 @@ on the procedure being called at any particular time." (unless (and (exception-with-origin? exn) (string=? (exception-origin exn) "fport_read")) - (display/knots "knots web-server, exception in client loop:\n" - (current-error-port)) - (display/knots - (call-with-output-string - (lambda (port) - (print-exception - port - #f - '%exception - (list exn)))) - (current-error-port))) + (display "knots web-server, exception in client loop:\n" + (current-error-port)) + (print-exception + (current-error-port) + #f + '%exception + (list exn))) #t) (lambda () (or @@ -505,29 +472,11 @@ on the procedure being called at any particular time." (else (let ((keep-alive? (handle-request handler client read-request-exception-handler - write-response-exception-handler - buffer-size - #:post-request-hook - post-request-hook))) + write-response-exception-handler))) (if keep-alive? (loop) (close-port client))))))) -(define (post-request-hook/safe post-request-hook) - (if post-request-hook - (lambda args - (with-exception-handler - (lambda (exn) #f) - (lambda () - (with-exception-handler - (lambda (exn) - (print-backtrace-and-exception/knots exn) - (raise-exception exn)) - (lambda () - (apply post-request-hook args)))) - #:unwind? #t)) - #f)) - (define-record-type (make-web-server socket port) web-server? @@ -547,8 +496,7 @@ on the procedure being called at any particular time." (write-response-exception-handler default-write-response-exception-handler) (connection-idle-timeout #f) - (connection-buffer-size 1024) - post-request-hook) + (connection-buffer-size 1024)) "Run the knots web server. HANDLER should be a procedure that takes one argument, the HTTP @@ -584,9 +532,7 @@ before sending back to the client." read-request-exception-handler write-response-exception-handler connection-idle-timeout - connection-buffer-size - (post-request-hook/safe - post-request-hook))) + connection-buffer-size)) #:parallel? #t) (loop)))))) diff --git a/tests.scm b/tests.scm index 0cca3b4..2b24c6a 100644 --- a/tests.scm +++ b/tests.scm @@ -1,11 +1,10 @@ (define-module (tests) #:use-module (ice-9 exceptions) #:use-module (fibers) - #:use-module (knots) #:export (run-fibers-for-tests assert-no-heap-growth)) -(define* (run-fibers-for-tests thunk #:key (drain? #t)) +(define (run-fibers-for-tests thunk) (let ((result (run-fibers (lambda () @@ -13,18 +12,15 @@ (lambda (exn) exn) (lambda () - (simple-format #t "running ~A\n" thunk) (with-exception-handler (lambda (exn) - (print-backtrace-and-exception/knots exn) + (backtrace) (raise-exception exn)) - (lambda () - (start-stack #t (thunk)))) + thunk) #t) #:unwind? #t)) #:hz 0 - #:parallelism 1 - #:drain? drain?))) + #:parallelism 1))) (if (exception? result) (raise-exception result) result))) diff --git a/tests/parallelism.scm b/tests/parallelism.scm index 91b2f3d..9881a4d 100644 --- a/tests/parallelism.scm +++ b/tests/parallelism.scm @@ -61,24 +61,6 @@ identity '(())))) -(run-fibers-for-tests - (lambda () - (with-exception-handler - (lambda (exn) - (unless (and (exception-with-message? exn) - (string=? (exception-message exn) - "foo")) - (raise-exception exn))) - (lambda () - (fibers-map-with-progress - (lambda _ - (raise-exception - (make-exception-with-message "foo"))) - '((1))) - - (error 'should-not-reach-here)) - #:unwind? #t))) - (run-fibers-for-tests (lambda () (with-exception-handler @@ -129,16 +111,4 @@ (assert-equal a 1)))) -(run-fibers-for-tests - (lambda () - (let ((parallelism-limiter (make-parallelism-limiter 2))) - (fibers-for-each - (lambda _ - (with-parallelism-limiter - parallelism-limiter - #f)) - (iota 50)) - - (destroy-parallelism-limiter parallelism-limiter)))) - (display "parallelism test finished successfully\n") diff --git a/tests/resource-pool.scm b/tests/resource-pool.scm index b3a84d7..1bc09e5 100644 --- a/tests/resource-pool.scm +++ b/tests/resource-pool.scm @@ -1,33 +1,9 @@ (use-modules (tests) (fibers) - (fibers channels) (unit-test) (knots parallelism) (knots resource-pool)) -(run-fibers-for-tests - (lambda () - (let ((parallelism-limiter (make-parallelism-limiter - 1))) - (with-parallelism-limiter parallelism-limiter - #f) - - (destroy-parallelism-limiter parallelism-limiter)))) - -(run-fibers-for-tests - (lambda () - (let ((parallelism-limiter (make-parallelism-limiter - 1)) - (channel - (make-channel))) - (spawn-fiber - (lambda () - (with-parallelism-limiter parallelism-limiter - (put-message channel #t) - (sleep 1)))) - (get-message channel) - (destroy-parallelism-limiter parallelism-limiter)))) - (define new-number (let ((val 0)) (lambda () @@ -43,21 +19,7 @@ (number? (with-resource-from-pool resource-pool res - res))) - - (destroy-resource-pool resource-pool)))) - -(run-fibers-for-tests - (lambda () - (let ((resource-pool (make-fixed-size-resource-pool - (list 1)))) - (assert-true - (number? - (with-resource-from-pool resource-pool - res - res))) - - (destroy-resource-pool resource-pool)))) + res)))))) (run-fibers-for-tests (lambda () @@ -69,9 +31,7 @@ (number? (with-resource-from-pool resource-pool res - res))) - - (destroy-resource-pool resource-pool)))) + res)))))) (let* ((error-constructor (record-constructor &resource-pool-timeout)) @@ -128,13 +88,10 @@ res)) (iota 20)) - (let loop ((stats (resource-pool-stats resource-pool - #:timeout #f))) + (let loop ((stats (resource-pool-stats resource-pool))) (unless (= 0 (assq-ref stats 'resources)) (sleep 0.1) - (loop (resource-pool-stats resource-pool #:timeout #f)))) - - (destroy-resource-pool resource-pool)))) + (loop (resource-pool-stats resource-pool))))))) (run-fibers-for-tests (lambda () @@ -158,9 +115,7 @@ (set! counter (+ 1 counter)) (error "collision detected"))))) 20 - (iota 50)) - - (destroy-resource-pool resource-pool)))) + (iota 50))))) (run-fibers-for-tests (lambda () @@ -174,7 +129,7 @@ (error "collision detected"))) (new-number)) 1 - #:default-checkout-timeout 5))) + #:default-checkout-timeout 120))) (fibers-batch-for-each (lambda _ (with-resource-from-pool @@ -185,9 +140,7 @@ (set! counter (+ 1 counter)) (error "collision detected"))))) 20 - (iota 50)) - - (destroy-resource-pool resource-pool)))) + (iota 50))))) (run-fibers-for-tests (lambda () @@ -211,14 +164,14 @@ (call-with-resource-from-pool resource-pool (lambda (res) - #f))) + (error 'should-not-be-reached)))) #:unwind? #t))) (while (= 0 (assq-ref - (resource-pool-stats resource-pool #:timeout #f) + (resource-pool-stats resource-pool) 'waiters)) - (sleep 0.1)) + (sleep 0)) (with-exception-handler (lambda (exn) @@ -231,55 +184,6 @@ resource-pool (lambda (res) (error 'should-not-be-reached)))) - #:unwind? #t))) - - (destroy-resource-pool resource-pool)))) - -(run-fibers-for-tests - (lambda () - (let ((resource-pool (make-resource-pool - (const 'foo) - 1 - #:lifetime 1 - #:destructor - (const #t)))) - (for-each - (lambda _ - (with-resource-from-pool resource-pool - res - res)) - (iota 20)) - - (destroy-resource-pool resource-pool)))) - -;; Test allocating resources to waiters and destroying resources -(run-fibers-for-tests - (lambda () - (let ((resource-pool (make-resource-pool - (lambda () - (sleep 1) - 'res) - 2 - #:idle-seconds 1 - #:add-resources-parallelism 10 - #:destructor - (const #t)))) - (fibers-for-each - (lambda _ - (with-resource-from-pool resource-pool - res - res)) - (iota 20)) - - (sleep 2) - - (fibers-for-each - (lambda _ - (with-resource-from-pool resource-pool - res - res)) - (iota 20)) - - (destroy-resource-pool resource-pool)))) + #:unwind? #t)))))) (display "resource-pool test finished successfully\n") diff --git a/tests/sort.scm b/tests/sort.scm deleted file mode 100644 index a80b84b..0000000 --- a/tests/sort.scm +++ /dev/null @@ -1,28 +0,0 @@ -(use-modules (tests) - (fibers) - (unit-test) - (knots sort)) - -(run-fibers-for-tests - (lambda () - (assert-equal - '() - (fibers-sort! '() <)) - - (assert-equal - '(1) - (fibers-sort! (list 1) <)) - - (assert-equal - '(1) - (fibers-sort! (list 1) < #:parallelism 10)) - - (assert-equal - '(1 2) - (fibers-sort! (list 2 1) <)) - - (assert-equal - (sort (reverse! (iota 100)) <) - (fibers-sort! (reverse! (iota 100)) < #:parallelism 10)))) - -(display "sort test finished successfully\n") diff --git a/tests/thread-pool.scm b/tests/thread-pool.scm index e3a1cdd..1c51cb3 100644 --- a/tests/thread-pool.scm +++ b/tests/thread-pool.scm @@ -1,5 +1,4 @@ (use-modules (tests) - (ice-9 atomic) (srfi srfi-71) (fibers) (unit-test) @@ -86,60 +85,4 @@ (+ 1 'a)))) #:unwind? #t))))) -(let ((thread-pool - (make-fixed-size-thread-pool - 1 - #:thread-lifetime 1 - #:thread-initializer - (lambda () - (list (make-atomic-box #t)))))) - - (for-each - (lambda _ - (call-with-thread - thread-pool - (lambda (box) - (if (atomic-box-ref box) - (atomic-box-set! box #f) - (error (atomic-box-ref box)))))) - (iota 10))) - -(run-fibers-for-tests - (lambda () - (let ((thread-pool - (make-thread-pool 1 #:thread-lifetime 1))) - - (for-each - (lambda _ - (call-with-thread - thread-pool - (lambda () #f))) - (iota 10))))) - -(let ((thread-pool - (make-fixed-size-thread-pool - 1 - #:thread-lifetime 2 - #:thread-initializer - (lambda () - (list (make-atomic-box 2)))))) - - (define (ref-and-decrement box) - (let ((val (atomic-box-ref box))) - (atomic-box-set! box (- val 1)) - val)) - - (unless (= 2 (call-with-thread - thread-pool - ref-and-decrement)) - (error)) - (unless (= 1 (call-with-thread - thread-pool - ref-and-decrement)) - (error)) - (unless (= 2 (call-with-thread - thread-pool - ref-and-decrement)) - (error))) - (display "thread-pool test finished successfully\n") diff --git a/tests/web-server.scm b/tests/web-server.scm index 67c6423..e456bf3 100644 --- a/tests/web-server.scm +++ b/tests/web-server.scm @@ -1,6 +1,5 @@ (use-modules (srfi srfi-71) (rnrs bytevectors) - (ice-9 match) (ice-9 binary-ports) (ice-9 textual-ports) (tests) @@ -234,68 +233,4 @@ (assert-equal (get-message exception-handled-sucecssfully-channel) #t)))) -(run-fibers-for-tests - (lambda () - (let* ((web-server - (run-knots-web-server - (lambda (request) - (match (split-and-decode-uri-path - (uri-path (request-uri request))) - (("head-no-body") - (values '((content-type . (text/plain))) - #f)) - (("head-empty-body") - (values '((content-type . (text/plain))) - "")) - (("head-no-body-with-content-length") - (values '((content-type . (text/plain)) - (content-length . 10)) - #f)) - (("head-with-body") - (values '((content-type . (text/plain))) - "foo")) - (("head-procedure-body") - (values '((content-type . (text/plain))) - (lambda _ - (error "should not be run")))) - (("head-procedure-body-with-content-length") - (values '((content-type . (text/plain)) - (content-length . 10)) - (lambda _ - (error "should not be run")))))) - #:port 0)) ;; Bind to any port - (port - (web-server-port web-server))) - - (define* (head path) - (let ((uri - (build-uri 'http #:host "127.0.0.1" #:port port - #:path path))) - (http-head - uri - #:port (non-blocking-open-socket-for-uri uri)))) - - (let ((response - (head "/head-no-body"))) - (assert-equal 200 (response-code response))) - (let ((response - (head "/head-empty-body"))) - (assert-equal 200 (response-code response)) - (assert-equal 0 (response-content-length response))) - (let ((response - (head "/head-no-body-with-content-length"))) - (assert-equal 200 (response-code response)) - (assert-equal 10 (response-content-length response))) - (let ((response - (head "/head-with-body"))) - (assert-equal 200 (response-code response)) - (assert-equal 3 (response-content-length response))) - (let ((response - (head "/head-procedure-body"))) - (assert-equal 200 (response-code response))) - (let ((response - (head "/head-procedure-body-with-content-length"))) - (assert-equal 200 (response-code response)) - (assert-equal 10 (response-content-length response)))))) - (display "web-server test finished successfully\n")