Incorporate a few x86_64 assembly routines from the latest GMP,
which provides a small speed boost for operations such as bignum
multiplication and division.
The difference between `abandon` and `close-output-port` seems to
matter for downloading PLaneT packages on some networks. Using
`abandon` does not seem to create any problems now that an extra
"\r\n" is not incorrecty included in PUT/POST requests.
Fix `path-element?` to check whether the name returned by split-path
is a path or a special entry. This behavior matches both the documentation
of `path-element?` and the implementation of `string->path-element`.
The warnings need to be suppressed only when compiling preprocessed
code during 3m compilation (because clang doesn't complain about
the relevant patterns when it knows that macros produced them).
Using MZ_INLINE on scheme_get_realint_val() and
scheme_get_unsigned_realint_val() leads to a link
error when using the current clang on Mac OS X 10.9.
Remove the MZ_INLINE declaration, since a modern C
compiler will inline, anyway.
The "props" file still has
* ".rkt" `drdr:timeout` entries, needed until DrDr uses submodules and
"info.rkt" files; although timeout information has been put in
submodules for `raco test`, DrDr uses `raco test` in a way that does not
enable timeouts, so that DrDr can implement timeouts itself (and record
when a test times out)
* ".rkt" `drdr:random #t` entries; not sure what to do with these, yet
* ".rkt" `responsible` entries; not sure what to do with these, yet
* ".rktl" `drdr:command-line #f` entries, needed until all ".rktl" files
are disabled in DrDr
The following files were previously disabled for DrDr testing, but were
intentionally left as enabled with these changes:
pkgs/racket-pkgs/racket-test/tests/pkg/shelly.rkt
pkgs/racket-pkgs/racket-test/tests/pkg/util.rkt
pkgs/racket-pkgs/racket-test/tests/pkg/info.rkt
pkgs/racket-pkgs/racket-test/tests/pkg/basic-index.rkt
pkgs/racket-pkgs/racket-test/tests/racket/link.rkt
pkgs/racket-pkgs/racket-test/tests/racket/embed-in-c.rkt
pkgs/racket-pkgs/racket-doc/ffi/examples/use-c-printf.rkt
pkgs/racket-pkgs/racket-doc/ffi/examples/c-printf.rkt
pkgs/parser-tools-pkgs/parser-tools-lib/parser-tools/private-lex/error-tests.rkt
pkgs/mysterx/mysterx.rkt
pkgs/mysterx/main.rkt
pkgs/games/gobblet/test-model.rkt
pkgs/games/gobblet/test-explore.rkt
pkgs/games/gobblet/robot.rkt
pkgs/games/gobblet/check.rkt
pkgs/db-pkgs/db-lib/db/private/odbc/main.rkt
pkgs/db-pkgs/db-lib/db/private/odbc/ffi.rkt
pkgs/db-pkgs/db-lib/db/private/odbc/dbsystem.rkt
pkgs/db-pkgs/db-lib/db/private/odbc/connection.rkt
pkgs/distributed-places-pkgs/distributed-places-lib/racket/place/distributed/examples/hello-world.rkt
pkgs/redex-pkgs/redex-lib/redex/private/compiler/match.rkt
pkgs/redex-pkgs/redex-lib/redex/private/compiler/match.rkt
pkgs/htdp-pkgs/htdp-test/2htdp/utest/balls.rkt
pkgs/gui-pkgs/gui-test/framework/tests/test-suite-utils.rkt
pkgs/games/paint-by-numbers/raw-problems/size-calculation.rkt
pkgs/db-pkgs/db-lib/db/odbc.rkt
pkgs/compatibility-pkgs/compatibility-lib/mzlib/traceld.rkt
pkgs/cext-lib/dynext/private/stdio.rkt
pkgs/db-pkgs/db-lib/db/odbc.rkt
racket/collects/ffi/unsafe/objc.rkt
racket/collects/ffi/objc.rkt
pkgs/racket-pkgs/racket-test/tests/pkg/tests-db.rkt
pkgs/racket-pkgs/racket-test/tests/pkg/test-docs.rkt
pkgs/racket-pkgs/racket-test/tests/pkg/test-catalogs-api.rkt
pkgs/gui-pkg-manager-pkgs/gui-pkg-manager-lib/pkg/gui/main.rkt
pkgs/redex-pkgs/redex-lib/redex/private/compiler/redextomatrix.rkt
pkgs/typed-racket-pkgs/typed-racket-lib/typed-racket/base-env/base-special-env.rkt
pkgs/planet-pkgs/planet-test/tests/planet/version.rkt
pkgs/planet-pkgs/planet-test/tests/planet/test-docs-complete.rkt
pkgs/planet-pkgs/planet-test/tests/planet/lang.rkt
pkgs/planet-pkgs/planet-test/tests/planet/docs-build.rkt
pkgs/drracket-pkgs/drracket-test/tests/drracket/follow-log.rkt
pkgs/drracket-pkgs/drracket/drracket/private/dock-icon.rkt
pkgs/drracket-pkgs/drracket-test/tests/drracket/tool-lib-and-sig.rkt
For example, make `raco exe --wrong` show "raco" instead of "racket"
as the error-reporting program. Normally, only `raco` and `setup-plt`
are implemented as "independent" launchers, because it's needed for
bootstrapping.
Now that the documentation-build phase of `raco setup` uses read-only
mode, contention between writing and reading sometimes (though
infrequently) triggers an SQLITE_IOERR_LOCK error. Change the SQLite
binding to expose that specific error, as well as SQLITE_IOERR_BLOCKED,
because a retry of the affected operation is appropriate.
Merge to release branch.
An invalid (needs-rollback?) transaction may correspond to a closed
underlying transaction. In that case, don't issue ROLLBACK command.
When `dynamic-require` is used to access an export that isn't a
variable defined in the same module, `dynamic-require` falls
back to `eval` in a fresh namespace, which can be expensive.
The new fast path handles the case that a variable is re-exported.
The new fast path is relevant to deserialization, which now
uses a submodule that re-exports from an enclosing module.
Commit 5bae9773aa broke `chaperone-procedure` and `impersonate-procedure`
so that it didn't always produce a chaperone or impersonator. Also,
the arity-error changeds intended for that commit were not complete,
because tests were accidentally commented out.
The main repair involves a new internal property that keeps track of an
accessor that is used to extract a procedure from a field in a structure
type that has `prop:procedure`.
Fixes a problem installation Planet packages under Windows,
for example, where attempting to open a read-only file in
write mode triggers an extremely slow result.
Merge bug fix to v6.0 (pending review)
Making the default match the docs fixes Planet package installation,
which otherwise tries to rebuild the index too frequently.
Merge bug fix to v6.0 (pending review)
The main change is to add an option to `syntax-local-infer-name` to
select whether `syntax-local-name` is used, and to use the new option
to disable `syntax-local-name` for the function expression in a
keyword `#%app`.
Improvements in the expander/compiler generalize a previous repair.
Merge to v6.0
Add "Connection: close" to requests that we know will end after one
request.
Read upto 1K bytes at a time on requests rather than just 1 at a time.
Change closing semantics to be "close" and not "abandon"
(not strictly necessary, but the new, still pending class/c first-order
checking checks the arities of the methods and those additional
tests got put into the test suite, so the easiest thing for now
is just to make the current class/c implementation do that check too)
Fix various problems, including a bad result from `procedure-arity`
and problems with chaperones and arity error messages when a
structure's `prop:procedure` value is a keyword-accepting procedure.
Merge to v6.0
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
When a GC is needed for the shared space, a GC is triggered
in all places, and the places wait until each other place
has completed. However, the places also need to wait until
all other places are ready to *start* a GC; otherwise, a
place may be modifying a shared record while some other place
traverses it for a GC.
Closes PR 14229
Merge to v6.0
closes PR 14170
Instead of checking free pvars of first template and using that to choose
which template to use, just try first and on failure try second.
Note: ?? still only covers absent pvars; non-#f non-stx value still
causes error; ellipsis rep mismatch still causes error; etc.
Allows some `raco` tools to work (such as `raco pkg`) when loading
information about other installed tools fails, so that problems can
be more easily corrected using working tools (other than `raco setup`,
which is a special case, anyway, for bootstrapping).
Closes PR 14221
Merge to v6.0
related to PR 14222
This doesn't completely fix that PR because the
implementation says that bytes are allowed and
the docs don't allow that. My guess is that the
implementation is wrong, not the docs, btu I'm not
sure and this may be a backwards compatibility
kind of thing, too. Also, path->collects-relative
should probably be considered (it doesn't allow
bytes? as an argument).
Make executables created by `raco exe` not refer to the original
configuration directory by default, but add an option for setting
the directory.
For Unix ELF executables, fix `raco exe` to set/preserve the
configuration directory.
Merge to v6.0
When rendering the user documentation-search page or
local-redirect page, only user-specific documentation is
included, which makes rendering faster and automatically
picks up any installation-scope additions.
The documentation start page is still static, so the
user version doesn't pick up installation-scope
additions in the same way.
Related to PR 14180
When the "racket-index" package is in user scope, then the
the documentation-build process should not try to write to
"doc" in the installation.
Merge to v6.0
A hash-table size grew based on the number of key slots occupied,
instead of the number of value slots, where the two differ when
keys are added and removed in the table.
Thanks to Ryan for the example.
