On this page:
make-compilation-manager-load/  use-compiled-handler

1.4 API for Making Bytecode

 (require compiler/cm) package: base
The compiler/cm module implements the compilation and dependency management used by raco make and raco setup.


  #:security-guard security-guard]) 
  (path? (or/c symbol? false/c) . -> . any)
  delete-zos-when-rkt-file-does-not-exist? : any/c = #f
  security-guard : (or/c security-guard? #f) = #f
Returns a procedure suitable as a value for the current-load/use-compiled parameter. The returned procedure passes its arguments on to the current-load/use-compiled procedure that is installed when make-compilation-manager-load/use-compiled-handler is called, but first it automatically compiles a source file to a ".zo" file if

If SHA-1 hashes override a timestamp-based decision to recompile the file, then the target ".zo" file’s timestamp is updated to the current time, unless the use-compiled-file-check parameter is not set to 'modify-seconds.

After the handler procedure compiles a ".zo" file, it creates a corresponding ".dep" file that lists the current version and the identification of every file that is directly required by the module in the compiled file. Additional dependencies can be installed during compilation via compiler/cm-accomplice. The ".dep" file also records the SHA-1 hash of the module’s source, and it records a combined SHA-1 hash of all of the dependencies that includes their recursive dependencies.

The handler caches timestamps when it checks ".dep" files, and the cache is maintained across calls to the same handler. The cache is not consulted to compare the immediate source file to its ".zo" file, which means that the caching behavior is consistent with the caching of the default module name resolver (see current-module-name-resolver).

If use-compiled-file-paths contains an empty list when make-compilation-manager-load/use-compiled-handler is called, then an exn:fail:contract exception is raised.

If the delete-zos-when-rkt-file-does-not-exist? argument is a true value, then the returned handler will delete ".zo" files when there is no corresponding original source file.

If the security-guard argument is supplied, it is used when creating ".zo" files, ".dep" files, and "compiled/" directories, and when it adjusts the timestamps for existing files. If it is #f, then the security guard in the current-security-guard when the files are created is used (not the security guard at the point make-compilation-manager-load/use-compiled-handler is called).

The continuation of the compilation of a module is marked with a managed-compiled-context-key and the module’s source path.

Do not install the result of make-compilation-manager-load/use-compiled-handler when the current namespace contains already-loaded versions of modules that may need to be recompiled—unless the already-loaded modules are never referenced by not-yet-loaded modules. References to already-loaded modules may produce compiled files with inconsistent timestamps and/or ".dep" files with incorrect information.

The handler logs messages to the topic 'compiler/cm at the level 'info. These messages are instances of a compile-event prefab structure:

(struct compile-event (timestamp path type) #:prefab)

The timestamp field is the time at which the event occured in milliseconds since the epoch. The path field is the path of a file being compiled for which the event is about. The type field is a symbol which describes the action the event corresponds to. The currently logged values are 'locking, 'start-compile, 'finish-compile, and 'already-done.

Changed in version of package base: Added identification of the compilation context via managed-compiled-context-key. Changed in version added check on a source’s SHA1 hash to complement the timestamp check, where the latter can be disabled via use-compile-file-check.


(managed-compile-zo file    
  #:security-guard security-guard])  void?
  file : path-string?
  read-src-syntax : (any/c input-port? . -> . syntax?)
   = read-syntax
  security-guard : (or/c security-guard? #f) = #f
Compiles the given module source file to a ".zo", installing a compilation-manager handler while the file is compiled (so that required modules are also compiled), and creating a ".dep" file to record the timestamps of immediate files used to compile the source (i.e., files required in the source).

If file is compiled from source, then read-src-syntax is used in the same way as read-syntax to read the source module. The normal read-syntax is used for any required files, however.

If security-guard is not #f, then the provided security guard is used when creating the "compiled/" directories, ".dep" and ".zo" files, and when it adjusts the timestamps of existing files. If it is #f, then the security guard in the current-security-guard when the files are created is used (not the security guard at the point managed-compile-zo is called).

While compiling file, the error-display-handler parameter is set to (make-compilation-context-error-display-handler (error-display-handler)), so that errors from uncaught exceptions will report the compilation context.

Changed in version of package base: Added error-display-handler configuration.

A key used as a continuation mark key by make-compilation-manager-load/use-compiled-handler for the continuation of a module compilation. The associated value is a path to the module’s source.

Added in version of package base.


(make-compilation-context-error-display-handler orig-handlers)

  (string? any/c . -> . void?)
  orig-handlers : (string? any/c . -> . void?)
Produces a handler suitable for use as an error-display-handler value, given an existing such value. The generated handler shows information about the compilation context when the handler’s second argument is an exception whose continuation marks include managed-compiled-context-key keys.

Added in version of package base.


(trust-existing-zos)  boolean?

(trust-existing-zos trust?)  void?
  trust? : any/c
A parameter that is intended for use by raco setup when installing with pre-built ".zo" files. It causes a compilation-manager load/use-compiled handler to “touch” out-of-date ".zo" files instead of re-compiling from source.


  #:security-guard security-guard]) 
  (path-string? . -> . void?)
  read-src-syntax : (any/c input-port? . -> . syntax?)
   = read-syntax
  security-guard : (or/c security-guard? #f) = #f
Returns a procedure that behaves like managed-compile-zo (providing the same read-src-syntax each time), but a cache of timestamp information is preserved across calls to the procedure.


(manager-compile-notify-handler)  (path? . -> . any)

(manager-compile-notify-handler notify)  void?
  notify : (path? . -> . any)
A parameter for a procedure of one argument that is called whenever a compilation starts. The argument to the procedure is the file’s path.


(manager-trace-handler)  (string? . -> . any)

(manager-trace-handler notify)  void?
  notify : (string? . -> . any)
A parameter for a procedure of one argument that is called to report compilation-manager actions, such as checking a file. The argument to the procedure is a string.

The default value of the parameter logs the argument, along with current-inexact-milliseconds, to a logger named 'compiler/cm at the 'debug level.



  (-> path? (or/c (cons/c number? promise?) #f))
(manager-skip-file-handler proc)  void?
  proc : (-> path? (or/c (cons/c number? promise?) #f))
A parameter whose value is called for each file that is loaded and needs recompilation. If the procedure returns a pair, then the file is skipped (i.e., not compiled); the number in the pair is used as the timestamp for the file’s bytecode, and the promise may be forced to obtain a string that is used as hash of the compiled file plus its dependencies. If the procedure returns #f, then the file is compiled as usual. The default is (lambda (x) #f).



  (or/c #f (-> path? (and/c path? relative-path?)))
(current-path->mode path->mode)  void?
  path->mode : (or/c #f (-> path? (and/c path? relative-path?)))
 = #f
Used by make-compilation-manager-load/use-compiled-handler and make-caching-managed-compile-zo to override use-compiled-file-paths for deciding where to write compiled ".zo" files. If it is #f, then the first element of use-compiled-file-paths is used. If it isn’t #f, then it is called with the original source file’s location and its result is treated the same as if it had been the first element of use-compiled-file-paths.

Note that this parameter is not used by current-load/use-compiled. So if the parameter causes ".zo" files to be placed in different directories, then the correct ".zo" file must still be communicated via use-compiled-file-paths, and one way to do that is to override current-load/use-compiled to delete ".zo" files that would cause the wrong one to be chosen right before they are loaded.

Added in version of package base.


(file-stamp-in-collection p)

  (or/c (cons/c number? promise?) #f)
  p : path?


(file-stamp-in-paths p paths)

  (or/c (cons/c number? promise?) #f)
  p : path?
  paths : (listof path?)
Returns the file-modification date and delayed hash of p or its bytecode form (i.e., ".zo" file), whichever exists and is newer, if p is an extension of any path in paths (i.e., exists in the directory, a subdirectory, etc.). Otherwise, the result is #f.

This function is intended for use with manager-skip-file-handler.


(get-file-sha1 p)  (or/c string? #f)

  p : path?
Computes a SHA-1 hash for the file p; the result is #f if p cannot be opened.


(get-compiled-file-sha1 p)  (or/c string? #f)

  p : path?
Computes a SHA-1 hash for the bytecode file p, appending any dependency-describing hash available from a ".dep" file when available (i.e., the suffix on p is replaced by ".dep" to locate dependency information). The result is #f if p cannot be opened.


(with-compile-output p proc)  any

  p : path-string?
  proc : ([port input-port?] [tmp-path path?]  . -> . any)
A wrapper on call-with-atomic-output-file that passes along any security guard put in place by make-compilation-manager-load/use-compiled-handler, etc.



(or/c #f
      (->i ([command (or/c 'lock 'unlock)]
            [file bytes?])
           [res (command) (if (eq? command 'lock)
(parallel-lock-client proc)  void?
  proc : 
(or/c #f
      (->i ([command (or/c 'lock 'unlock)]
            [file bytes?])
           [res (command) (if (eq? command 'lock)
Holds the parallel compilation lock client, which is used by the result of make-compilation-manager-load/use-compiled-handler to prevent compilation races between parallel builders.

When proc is #f (the default), no checking for parallel compilation is done (and thus multiple threads or places running compilations via make-compilation-manager-load/use-compiled-handler will potentially corrupt each other’s ".zo" files).

When proc is a function, its first argument is a command, indicating if it wants to lock or unlock the path specified in the second argument.

When the proc 'lock command returns #t, the current builder has obtained the lock for zo-path. Once compilation of zo-path is complete, the builder process must release the lock by calling proc 'unlock with the exact same zo-path.

When the proc 'lock command returns #f, another parallel builder obtained the lock first and has already compiled the zo. The parallel builder should continue without compiling zo-path. (In this case, make-compilation-manager-load/use-compiled-handler’s result will not call proc with 'unlock.)

> (let* ([lc (parallel-lock-client)]
         [zo-name  #"collects/racket/compiled/draw_rkt.zo"]
         [locked? (and lc (lc 'lock zo-name))]
         [ok-to-compile? (or (not lc) locked?)])
      (lambda () (void))
      (lambda ()
        (when ok-to-compile?
          (printf "Do compile here ...\n")))
      (lambda ()
        (when locked?
          (lc 'unlock zo-name)))))

Do compile here ...


(compile-lock->parallel-lock-client pc 
  (-> (or/c 'lock 'unlock) bytes? boolean?)
  pc : place-channel?
  cust : (or/c #f custodian?) = #f
Returns a function that follows the parallel-lock-client by communicating over pc. The argument must be the result of make-compile-lock.

This communication protocol implementation is not kill safe. To make it kill safe, it needs a sufficiently powerful custodian, i.e., one that is not subject to termination (unless all of the participants in the compilation are also terminated). It uses this custodian to create a thread that monitors the threads that are doing the compilation. If one of them is terminated, the presence of the custodian lets another one continue. (The custodian is also used to create a thread that manages a thread safe table.)


(make-compile-lock)  place-channel?

Creates a place-channel? that can be used with compile-lock->parallel-lock-client to avoid concurrent compilations of the same Racket source files in multiple places.


(install-module-hashes! bstr [start end])  void?

  bstr : btyes?
  start : exact-nonnegatve-integer? = 0
  end : exact-nonnegatve-integer? = (bytes-length bstr)
Adjusts the bytecode representation in bstr (from bytes start to end) to install a hash code, including any submodules within the region. The existing representation should have zero bytes in place of each hash string, which is what write produces for a compiled form.

Added in version 6.3 of package base.