+;;; A unique GC id. This is supplied for code that needs to detect
+;;; whether a GC has happened since some earlier point in time. For
+;;; example:
+;;;
+;;; (let ((epoch *gc-epoch*))
+;;; ...
+;;; (unless (eql epoch *gc-epoch)
+;;; ....))
+;;;
+;;; This isn't just a fixnum counter since then we'd have theoretical
+;;; problems when exactly 2^29 GCs happen between epoch
+;;; comparisons. Unlikely, but the cost of using a cons instead is too
+;;; small to measure. -- JES, 2007-09-30
+(declaim (type cons *gc-epoch*))
+(defvar *gc-epoch* (cons nil nil))
+
+(defun sub-gc (&key (gen 0))
+ (cond (*gc-inhibit*
+ (setf *gc-pending* t)
+ nil)
+ (t
+ (without-interrupts
+ (setf *gc-pending* :in-progress)
+ ;; Tricks to to prevent triggerring a recursive gc. This is
+ ;; like a WITHOUT-GCING inside the lock except that we
+ ;; cannot call MAYBE-HANDLE-PENDING-GC at the end, because
+ ;; that would lead to a recursive attempt on the lock. In
+ ;; case you are wondering, wrapping the lock in a
+ ;; WITHOUT-GCING would also deadlock. The
+ ;; *IN-WITHOUT-GCING* part is used to tell the runtime that
+ ;; it's ok to have a pending gc even though *GC-INHIBIT* is
+ ;; NIL.
+ ;;
+ ;; Now, if GET-MUTEX did not cons, that would be enough.
+ ;; Because it does, we need the :IN-PROGRESS bit above to
+ ;; tell the runtime not to trigger gcs.
+ (let ((sb!impl::*in-without-gcing* t)
+ (sb!impl::*deadline* nil)
+ (sb!impl::*deadline-seconds* nil))
+ (sb!thread:with-mutex (*already-in-gc*)
+ (let ((*gc-inhibit* t))
+ (let ((old-usage (dynamic-usage))
+ (new-usage 0))
+ (unsafe-clear-roots)
+ (gc-stop-the-world)
+ (let ((start-time (get-internal-run-time)))
+ (collect-garbage gen)
+ (setf *gc-epoch* (cons nil nil))
+ (incf *gc-run-time*
+ (- (get-internal-run-time) start-time)))
+ (setf *gc-pending* nil
+ new-usage (dynamic-usage))
+ #!+sb-thread
+ (assert (not *stop-for-gc-pending*))
+ (gc-start-the-world)
+ ;; In a multithreaded environment the other threads
+ ;; will see *n-b-f-o-p* change a little late, but
+ ;; that's OK.
+ (let ((freed (- old-usage new-usage)))
+ ;; GENCGC occasionally reports negative here, but
+ ;; the current belief is that it is part of the
+ ;; normal order of things and not a bug.
+ (when (plusp freed)
+ (incf *n-bytes-freed-or-purified* freed)))))))
+ ;; While holding the mutex we were protected from
+ ;; SIG_STOP_FOR_GC and recursive GCs. Now, in order to
+ ;; preserve the invariant (*GC-PENDING* ->
+ ;; pseudo-atomic-interrupted or *GC-INHIBIT*), let's check
+ ;; explicitly for a pending gc before interrupts are
+ ;; enabled again.
+ (maybe-handle-pending-gc))
+ t)))
+
+(defun post-gc ()
+ ;; Outside the mutex, interrupts may be enabled: these may cause
+ ;; another GC. FIXME: it can potentially exceed maximum interrupt
+ ;; nesting by triggering GCs.
+ ;;
+ ;; Can that be avoided by having the finalizers and hooks run only
+ ;; from the outermost SUB-GC? If the nested GCs happen in interrupt
+ ;; handlers that's not enough.
+ ;;
+ ;; KLUDGE: Don't run the hooks in GC's if:
+ ;;
+ ;; A) this thread is dying, so that user-code never runs with
+ ;; (thread-alive-p *current-thread*) => nil
+ ;;
+ ;; B) interrupts are disabled somewhere up the call chain since we
+ ;; don't want to run user code in such a case.
+ ;;
+ ;; The long-term solution will be to keep a separate thread for
+ ;; finalizers and after-gc hooks.
+ (when (sb!thread:thread-alive-p sb!thread:*current-thread*)
+ (when *allow-with-interrupts*
+ (with-interrupts
+ (run-pending-finalizers)
+ (call-hooks "after-GC" *after-gc-hooks* :on-error :warn)))))