Skip to content

Instantly share code, notes, and snippets.

Forked from greghendershott/bench.rkt
Created November 9, 2012 15:52
Show Gist options
  • Save takikawa/4046452 to your computer and use it in GitHub Desktop.
Save takikawa/4046452 to your computer and use it in GitHub Desktop.
Why is a simple contract so much slower than a check?
#lang racket
(define (f/raw x)
(define (f/checked x)
(unless (exact-nonnegative-integer? x)
(error 'f/checked "blah blah"))
(define f/chaperoned
(λ (x) (contract exact-nonnegative-integer? x 'pos 'neg))))
;; using contract-out
(module f racket
[f/from-module (-> exact-nonnegative-integer? any)]))
(define (f/from-module x) #t))
(require 'f)
(define/contract (f/contracted x)
(exact-nonnegative-integer? . -> . any)
(define count 100000)
(define-syntax-rule (bench func)
(display (object-name func)) (display ": ")
(time (for ([i (in-range count)])
(func i)))
(bench f/raw)
(bench f/checked)
(bench f/contracted)
(bench f/chaperoned)
(bench f/from-module)
Example output:
cpu time real time gc time
f/raw: 4 4 0
f/checked: 6 6 0
f/contracted: 1166 1197 211
Naively I would expect the simple contract to result in code
not _too_ much more complicated or slower than the manual check.
1. Why not?
2. Could simple contracts be (nearly) as fast as manual checks?
To get the declarative convenince and clarity of contracts, without
so much overhead?
Copy link

samth commented Nov 12, 2012

And the chaperone performance results?

Copy link

@samth Running the above I get:

f/raw: cpu time: 4 real time: 4 gc time: 0
f/checked: cpu time: 6 real time: 6 gc time: 0
f/contracted: cpu time: 1288 real time: 1327 gc time: 341
f/raw: cpu time: 204 real time: 211 gc time: 66  <-- really f/chaperone, not f/raw
f/from-module: cpu time: 22 real time: 22 gc time: 0

@samth @takikawa
FWIW I took my original gist further:

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment