The main changes are the addition of a new way to specify projections,
using the #:val-first-projection keyword argument; the main goal of the
new API is that more information can be supplied to the projection on
the server side of the contract boundary. In addition, the arrow contracts
will now, internally and in some cases (see define-module-boundary-contract)
return functions that accept one additional argument than the original
function did and then insert the name of the negative party into call sites.
The rough idea is that if you have a program like this one:
#lang racket/base
(define (f x) (+ x 1))
(provide (contract-out [f (-> integer? integer?)]))
then the contract system produces something much closer to this:
#lang racket/base
(define (f x) (+ x 1))
(provide (rename-out [external-f f]))
(define (external-f neg-party x)
(check-integer neg-party x)
(define ans (f x))
(check-integer neg-party ans)
ans)
(define local-blame-information ...)
(define (check-integer neg-party v)
(unless (integer? v)
(raise-blame-error local-blame-information
#:missing-party neg-party
...)))
where 'raise-blame-error' can now cope with blame objects that don't
have negative part information in them (when the #:missing-party
argument is supplied, essentially just reassembling the original blame
record at that point)
Then, on the client side, if we had
(f x)
it gets transformed into
(f '<<my-modules-name>> x)
and if we had
(let ([g f])
...)
you get a slow path:
(let ([g (lambda (x) (f '<<my-modules-name>> x))])
...)
(where we don't create a wrapper lambda, of course, we actually create
a procedure chaperone)
The performance improvements seem pretty good (see below for the
precise programs that I ran and the numbers I got):
first order contract microbenchmark: 6x speedup
higher-order contract microbenchmark: 1.5x speedup
first-order TR contract interop micro benchmark: 6x speedup
This also improves the memory use for DrRacket by about 3% (from about
236.8 mb to 231.3 mb), presumably because more of the data structures
created by the contract system can be created only once, on the server
side.
Be aware, however, that not all combinators are using the new
projections and the code that translates between the two APIs
is slow.
Also there are a bunch of other changes that got made while I was
doing this. Most notably, the change above were not designed for the
performance improvements to arrow contracts, but to make it possible
to implement class/c contracts with a (hopefully) negligible space
overhead. That work is not yet finished, but this commit includes some
changes to the class system to prepare the way for those changes.
Unfortuantely, these changes slow down 'send' on microbenchmarks by
about 24%. The change comes from the addition of an extra 'if' (and
predicate test and possibly the extra let expresison) that's inserted
into the expansion. I'm not happy about that (I was shooting for 10%)
but I'm not sure that we can do much about it (except perhaps double
check my measurements, see below).
Other misc changes:
- improve arity mismatch error messages by including the arity of the
given procedure (closes PR 14220)
- Adjust case-> so it generates less code. This seems to reduce the
size of the math library .zo files by about 3% (from 10440k to
10156k for me)
- speeds up the contract tests a bit
- move recontract out into racket/contract (also, document it)
- added define-module-boundary-contract
- streamline TR's any-wrap/c and adjust it to use
#:val-first-projection instead of #:projection
- adjust a bunch of contracts to print more nicely
- and, of course, Rackety
--------------------------------
The precise programs that I tried and their timings (the raw data
for the performance claims above):
#lang racket/base
(module m racket/base
(require racket/contract/base)
(define (f x) x)
(provide (contract-out [f (-> any/c any/c)])))
(require 'm)
(time
(for ([x (in-range 100000)])
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)))
pre-push timings:
cpu time: 3553 real time: 3552 gc time: 52
cpu time: 3548 real time: 3552 gc time: 52
cpu time: 3525 real time: 3525 gc time: 54
cpu time: 3547 real time: 3547 gc time: 47
post-push timings:
cpu time: 515 real time: 515 gc time: 15
cpu time: 522 real time: 522 gc time: 17
cpu time: 560 real time: 560 gc time: 19
cpu time: 514 real time: 515 gc time: 19
cpu time: 507 real time: 507 gc time: 17
A second order example using vectors (note that vector/c isn't yet
updated to the #:val-first-projection, so it will be way slower)
#lang racket/base
(module m racket/base
(require racket/contract/base)
(define (f x) (vector-ref x 0))
(provide (contract-out [f (-> (vectorof any/c) any/c)])))
(require 'm)
(define v (vector void))
(time
(for ([x (in-range 10000)])
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)
(f v) (f v) (f v) (f v) (f v) (f v) (f v) (f v)))
pre-push timings:
cpu time: 744 real time: 745 gc time: 20
cpu time: 679 real time: 679 gc time: 18
cpu time: 695 real time: 695 gc time: 23
cpu time: 743 real time: 742 gc time: 21
cpu time: 780 real time: 786 gc time: 21
cpu time: 723 real time: 726 gc time: 25
post-push timings:
cpu time: 448 real time: 448 gc time: 18
cpu time: 470 real time: 469 gc time: 19
cpu time: 466 real time: 465 gc time: 16
cpu time: 457 real time: 456 gc time: 15
cpu time: 465 real time: 466 gc time: 24
Using contracts in TR
#lang racket/base
(module m typed/racket/base
(: f (Any -> Any))
(define (f x) x)
(provide f))
(require 'm)
(time
(for ([x (in-range 10000)])
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)
(f 1) (f 2) (f 3) (f 4) (f 5) (f 6) (f 7) (f 8)))
pre-push timings:
cpu time: 357 real time: 357 gc time: 6
cpu time: 446 real time: 447 gc time: 4
cpu time: 361 real time: 359 gc time: 4
cpu time: 366 real time: 366 gc time: 5
cpu time: 368 real time: 367 gc time: 6
post-push timings
cpu time: 63 real time: 63 gc time: 7
cpu time: 64 real time: 63 gc time: 8
cpu time: 63 real time: 64 gc time: 8
cpu time: 58 real time: 58 gc time: 8
cpu time: 59 real time: 59 gc time: 7
Slowdown for 'send':
#lang racket/base
(require racket/class)
(define c% (class object% (define/public (m x) x) (super-new)))
(define o (new c%))
(time
(for ([x (in-range 100000)])
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)
(send o m 1) (send o m 2) (send o m 3) (send o m 4)
(send o m 5) (send o m 6) (send o m 7) (send o m 8)))
timings pre-push:
cpu time: 251 real time: 251 gc time: 0
cpu time: 275 real time: 275 gc time: 0
cpu time: 250 real time: 250 gc time: 0
cpu time: 246 real time: 246 gc time: 0
cpu time: 247 real time: 246 gc time: 0
timings post-push:
cpu time: 303 real time: 302 gc time: 0
cpu time: 333 real time: 333 gc time: 0
cpu time: 315 real time: 315 gc time: 0
cpu time: 317 real time: 317 gc time: 0
cpu time: 311 real time: 310 gc time: 0
original commit: c321f6dd0c4e2444d44b6c79a3ac49acfb9041bf
A few of these had unnecessary uses of type variables.
The type for `remove*` was unsound.
Please merge to v6.0
original commit: a98e4c5474f83cc146b62baf64c3fa2ee8132fef
and sometimes when there are syntax errors raised
In more detail, rearrange online check syntax's internal plumbing
so that syntax objects can be handed to check syntax at any point
(via a special log message, see the changes to the docs)
not just when expansion is finished
Use this in TR to get check syntax information even when there is
a type error (and also get the check syntax information processing
started before type checking starts (altho this isn't running
in a separate place, so there is no new parallelism here))
original commit: 09920bd8ce46f15d9cf4a5066ab2cfb84bbdd417
Now for functions with simple filters, it'll negate the
filters so that, e.g., (negate string?) can be used with
occurrence typing.
Please merge to v6.0
original commit: 0f8ee738142c8e253c638c836fc1c5c893751d32
This solves the immediate problem, but more generally the
handling of ignored syntax at the top-level seems very fishy.
There is a complicated protocol involving the top-level
type-checker returning #<void> for cases with no obvious
return type, but it's unclear if it actually works. That
code in tc-toplevel.rkt should be revamped in the future.
Closes PR 14030
Please merge into 6.0
original commit: f292a9c0f277bc07d0932ed67f893ca1cb022a43
Add a mode to the profiler to use continuation marks inserted
by the errortrace annotator instead of the runtime.
Split `syntax/source-syntax` out from Typed Racket as a separate package,
and use it to give better names for errortrace stack frames.
Use caching to speed it up substantially when called repeatedly (as
errortrace does).
Also, document (internally) the format used by errortrace marks.
original commit: 1e7eb34ba170b6aad77ee67c0f4b802950ff1a4b
