X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=src%2Fcompiler%2Fgeneric%2Fparms.lisp;h=ea3224711d2f227fcff112d5796cfec3d9e66d63;hb=19319c931fc1636835dbef71808cc10e252bcf45;hp=c2691bd84e7a346c3eb86edee78b9599047c9ab2;hpb=edb227f57bcf629a9e8c3b8e6e1b37d644d8f217;p=sbcl.git diff --git a/src/compiler/generic/parms.lisp b/src/compiler/generic/parms.lisp index c2691bd..ea32247 100644 --- a/src/compiler/generic/parms.lisp +++ b/src/compiler/generic/parms.lisp @@ -12,20 +12,122 @@ (in-package "SB!VM") +(def!macro !configure-dynamic-space-end (&optional default) + (with-open-file (f "output/dynamic-space-size.txt") + (let ((line (read-line f))) + (multiple-value-bind (number end) + (parse-integer line :junk-allowed t) + (if number + (let* ((ext (subseq line end)) + (mult (cond ((or (zerop (length ext)) + (member ext '("MB MIB") :test #'equalp)) + (expt 2 20)) + ((member ext '("GB" "GIB") :test #'equalp) + (expt 2 30)) + (t + (error "Invalid --dynamic-space-size=~A" line))))) + `(+ dynamic-space-start ,(* number mult))) + (or default + `(+ dynamic-space-start + (ecase n-word-bits + (32 (expt 2 29)) + (64 (expt 2 30)))))))))) + +#!+gencgc +;; Define START/END constants for GENCGC spaces. +;; Assumptions: +;; We only need very small read-only and static spaces, because +;; gencgc does not purify any more. We can count on being able to +;; allocate them with roughly the same size, and next to each other. +;; +;; There is one page of unmapped buffer between them for good measure. +;; +;; The linkage table (if enabled) can be treated the same way. +;; +;; Dynamic space traditionally sits elsewhere, so has its own +;; parameter. But if not specified, it is allocated right after +;; the other spaces (used on Windows/x86). +;; +;; The safepoint page (if enabled) is to be allocated immediately +;; prior to static page. For x86(-64) this would not matter, because +;; they can only reference it using an absolute fixup anyway, but +;; for RISC platforms we can (and must) do better. +;; +;; The safepoint page needs to be small enough that the offset from +;; static space is immediate, e.g. >= -2^12 for SPARC. #x1000 works +;; for almost all platforms, but is too small to make VirtualProtect +;; happy -- hence the need for an extra `alignment' configuration +;; option below, which parms.lisp can set to #x10000 on Windows. +;; +;; Cosmetic problem: +;; +;; In the interest of readability, &KEY would be much nicer than +;; &OPTIONAL. But is it possible to use keyword arguments to +;; DEF!MACRO? +;; +(def!macro !gencgc-space-setup + (small-spaces-start + &optional dynamic-space-start* + default-dynamic-space-size + ;; Smallest os_validate()able alignment; used as safepoint + ;; page size. Default suitable for POSIX platforms. + (alignment #x1000) + ;; traditional distance between spaces -- including the margin: + (small-space-spread #x100000) + ;; traditional margin between spaces + (margin-size #x1000)) + (let* ((spaces '(read-only static #!+linkage-table linkage-table)) + (ptr small-spaces-start) + safepoint-address + (small-space-forms + (loop for (space next-space) on spaces appending + (let* ((next-start (+ ptr small-space-spread)) + (end next-start)) + (when (eq next-space 'static) + ;; margin becomes safepoint page; substract margin again. + (decf end alignment) + (setf safepoint-address end)) + (prog1 + `((def!constant ,(symbolicate space "-SPACE-START") + ,ptr) + (def!constant ,(symbolicate space "-SPACE-END") + ,(- end margin-size))) + (setf ptr next-start))))) + (safepoint-page-forms + (list #!+sb-safepoint + `(def!constant gc-safepoint-page-addr ,safepoint-address))) + (dynamic-space-start* (or dynamic-space-start* ptr)) + (optional-dynamic-space-end + (when default-dynamic-space-size + (list (+ dynamic-space-start* default-dynamic-space-size))))) + `(progn + ,@safepoint-page-forms + ,@small-space-forms + (def!constant dynamic-space-start ,dynamic-space-start*) + (def!constant dynamic-space-end (!configure-dynamic-space-end + ,@optional-dynamic-space-end))))) + (defparameter *c-callable-static-symbols* '(sub-gc + sb!kernel::post-gc sb!kernel::internal-error sb!kernel::control-stack-exhausted-error + sb!kernel::binding-stack-exhausted-error + sb!kernel::alien-stack-exhausted-error sb!kernel::heap-exhausted-error sb!kernel::undefined-alien-variable-error - sb!kernel::undefined-alien-function-error sb!kernel::memory-fault-error sb!kernel::unhandled-trap-error + ;; On x86-64 it's called through the internal errors mechanism + #!-x86-64 undefined-alien-fun-error sb!di::handle-breakpoint sb!di::handle-single-step-trap fdefinition-object - #!+sb-thread sb!thread::run-interruption - #!+win32 sb!kernel::handle-win32-exception)) + #!+win32 sb!kernel::handle-win32-exception + #!+sb-thruption sb!thread::run-interruption + #!+sb-safepoint sb!thread::enter-foreign-callback + #!+(and sb-safepoint-strictly (not win32)) + sb!unix::signal-handler-callback)) (defparameter *common-static-symbols* '(t @@ -57,17 +159,34 @@ sb!unix::*allow-with-interrupts* sb!unix::*interrupts-enabled* sb!unix::*interrupt-pending* - *in-without-gcing* + #!+sb-thruption sb!unix::*thruption-pending* + #!+sb-thruption sb!impl::*restart-clusters* + sb!vm::*in-without-gcing* *gc-inhibit* *gc-pending* #!-sb-thread *stepping* + #!+sb-safepoint sb!impl::*gc-safe* + #!+sb-safepoint sb!impl::*in-safepoint* + + ;; threading support + #!+sb-thread *stop-for-gc-pending* + #!+sb-thread *free-tls-index* + #!+sb-thread *tls-index-lock* + + ;; dynamic runtime linking support + #!+sb-dynamic-core *required-runtime-c-symbols* + sb!kernel::*gc-epoch* ;; Dispatch tables for generic array access - sb!impl::*data-vector-reffers* - sb!impl::*data-vector-setters* - sb!impl::*data-vector-reffers/check-bounds* - sb!impl::*data-vector-setters/check-bounds* + sb!impl::%%data-vector-reffers%% + sb!impl::%%data-vector-reffers/check-bounds%% + sb!impl::%%data-vector-setters%% + sb!impl::%%data-vector-setters/check-bounds%% + + ;; non-x86oid gencgc object pinning + #!+(and gencgc (not (or x86 x86-64))) + *pinned-objects* ;; hash table weaknesses :key @@ -78,3 +197,14 @@ ;;; Number of entries in the thread local storage. Limits the number ;;; of symbols with thread local bindings. (def!constant tls-size 4096) + +#!+gencgc +(progn + (def!constant +highest-normal-generation+ 5) + (def!constant +pseudo-static-generation+ 6)) + +(defenum () + trace-table-normal + trace-table-call-site + trace-table-fun-prologue + trace-table-fun-epilogue)