I was very curious about what you were talking about, as I saw wildly
different numbers (in line with what I'd seen before).
However, I did the following test:
|> ~/tools/racket/6.1.1/bin/racket typed_divide.rkt
cpu time: 536 real time: 537 gc time: 27
cpu time: 347 real time: 347 gc time: 4
cpu time: 87 real time: 84 gc time: 0
|> ~/tools/racket/6.2.0/bin/racket typed_divide.rkt
cpu time: 567 real time: 565 gc time: 10
cpu time: 960 real time: 958 gc time: 13
cpu time: 83 real time: 84 gc time: 0
|> ~/tools/racket/6.2.1/bin/racket typed_divide.rkt
cpu time: 600 real time: 601 gc time: 70
cpu time: 970 real time: 974 gc time: 23
cpu time: 86 real time: 85 gc time: 0
The below program is what's being run:
#lang racket/base
(module t typed/racket/base
(: divides? : Integer Integer -> Boolean)
(define (divides? a b)
(cond
[(zero? a) #f]
[else (= (remainder b a) 0)]))
(provide divides?))
(module c racket/base
(require racket/contract/base)
(define (divides? a b)
(cond [(zero? a) #f]
[else (= (remainder b a) 0)]))
(provide
(contract-out
[divides? (-> exact-integer? exact-integer? boolean?)])))
(module no-contract racket/base
(define (divides? a b)
(cond
[(zero? a)
#f]
[else
(= (remainder b a) 0)]))
(provide divides?))
(require (prefix-in with-contract: (submod "." c)))
(require (prefix-in typed: (submod "." t)))
(require (prefix-in no-contract: (submod "." no-contract)))
(time
(for ([x (in-range 3 5000000)])
(if (3 . with-contract:divides? . x)
x
0)))
(time
(for ([x (in-range 3 5000000)])
(if (3 . typed:divides? . x)
x
0)))
(time
(for ([x (in-range 3 5000000)])
(if (3 . no-contract:divides? . x)
x
0)))
On Mon, 24 Aug 2015, Robby Findler wrote:
My message below is not doing the right test. This is the right test
and it produces the expected result, namely that the TR version runs a
bit faster (presumably because of type-based optimizations that TR
does).
Robby
#lang racket
(module t typed/racket/base
(: divides? : Integer Integer -> Boolean)
(define (divides? a b)
(cond [(zero? a) #f]
[else (= (remainder b a) 0)]))
(provide divides?))
(module c racket/base
(require racket/contract/base)
(define (divides? a b)
(cond [(zero? a) #f]
[else (= (remainder b a) 0)]))
(provide
(contract-out
[divides? (-> exact-integer? exact-integer? boolean?)])))
(require (prefix-in c: (submod "." c)))
(require (prefix-in t: (submod "." t)))
(time
(for ([x (in-range 3 5000000)])
(if (3 . c:divides? . x)
x
0)))
(time
(for ([x (in-range 3 5000000)])
(if (3 . t:divides? . x)
x
0)))
On Mon, Aug 24, 2015 at 8:18 AM, Robby Findler
<[email protected]> wrote:
It looks to me like the slowdown isn't entirely explained by contract
checking, or perhaps TR isn't generating the contracts I would have
guessed. With the program below, I see this output
cpu time: 1228 real time: 1228 gc time: 133
cpu time: 658 real time: 658 gc time: 18
cpu time: 80 real time: 81 gc time: 0
but would have expected the first two lines to be nearly the same.
Robby
#lang racket
(require (only-in math/number-theory divides?))
(define (divisible-by? x d)
(= (modulo x d)
0))
(module d racket/base
(require racket/contract/base)
(define (divisible-by? x d)
(= (modulo x d)
0))
(provide
(contract-out
[divisible-by? (-> exact-integer? exact-integer? boolean?)])))
(require (prefix-in c: (submod "." d)))
(module+ main
(time
(for ([x (in-range 3 5000000)])
(if (3 . divides? . x)
x
0)))
(time
(for ([x (in-range 3 5000000)])
(if (3 . c:divisible-by? . x)
x
0)))
(time
(for ([x (in-range 3 5000000)])
(if (x . divisible-by? . 3)
x
0))))
--
You received this message because you are subscribed to the Google Groups "Racket
Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
