;; TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
;; SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-;; $Id: proxy.lisp,v 1.26 2006-02-06 11:52:24 espen Exp $
+;; $Id: proxy.lisp,v 1.31 2006-02-08 22:10:47 espen Exp $
(in-package "GLIB")
(slot-definition-type slotd))))
(funcall writer (foreign-location object) value)))))))))
- (initialize-internal-slot-gfs (slot-definition-name slotd)))
+ #-sbcl>=0.9.8(initialize-internal-slot-gfs (slot-definition-name slotd)))
;;;; Proxy cache
-(internal *instance-cache*)
(defvar *instance-cache* (make-hash-table :test #'eql))
(defun cache-instance (instance &optional (weak-ref t))
*instance-cache*)
instances))
+;; Instances that gets invalidated tend to be short lived, but created
+;; in large numbers. So we're keeping them in a hash table to be able
+;; to reuse them (and thus reduce consing)
+(defvar *invalidated-instance-cache* (make-hash-table :test #'eql))
+
+(defun cache-invalidated-instance (instance)
+ (push instance
+ (gethash (class-of instance) *invalidated-instance-cache*)))
+
+(defun find-invalidated-instance (class)
+ (when (gethash class *invalidated-instance-cache*)
+ (pop (gethash class *invalidated-instance-cache*))))
+
+(defun list-invalidated-instances ()
+ (let ((instances ()))
+ (maphash #'(lambda (location ref)
+ (declare (ignore location))
+ (push ref instances))
+ *invalidated-instance-cache*)
+ instances))
+
;;;; Proxy for alien instances
;; TODO: add a ref-counted-proxy subclass
(defclass proxy ()
- ((location :allocation :special :reader foreign-location :type pointer))
+ ((location :allocation :special :type pointer))
(:metaclass virtual-slots-class))
(defgeneric instance-finalizer (object))
(defgeneric unreference-foreign (class location))
(defgeneric invalidate-instance (object))
+(defun foreign-location (instance)
+ (slot-value instance 'location))
+
+(defun (setf foreign-location) (location instance)
+ (setf (slot-value instance 'location) location))
+
+(defun proxy-valid-p (instance)
+ (slot-boundp instance 'location))
+
(defmethod reference-foreign ((name symbol) location)
(reference-foreign (find-class name) location))
(remove-cached-instance location)
(unreference-foreign class location))))
+;; Any reference to the foreign object the instance may have held
+;; should be released before this method is invoked
(defmethod invalidate-instance ((instance proxy))
(remove-cached-instance (foreign-location instance))
- (slot-makunbound instance 'location))
+ (slot-makunbound instance 'location)
+ (cancel-finalization instance)
+ (cache-invalidated-instance instance))
;;;; Metaclass used for subclasses of proxy
(defgeneric most-specific-proxy-superclass (class))
(defgeneric direct-proxy-superclass (class))
-(defgeneric compute-foreign-size (class))
(eval-when (:compile-toplevel :load-toplevel :execute)
(call-next-method))
- (defmethod compute-foreign-size ((class proxy-class))
- nil)
-
;; TODO: call some C code to detect this a compile time
(defconstant +struct-alignmen+ 4)
do (setf (slot-value slotd 'offset) offset))))
(call-next-method))
- (defmethod compute-slots :after ((class proxy-class))
- (when (and (class-finalized-p class) (not (slot-boundp class 'size)))
- (let ((size (compute-foreign-size class)))
- (when size
- (setf (slot-value class 'size) size)))))
-
(defmethod validate-superclass ((class proxy-class) (super standard-class))
(subtypep (class-name super) 'proxy))
(defmethod reader-function ((class proxy-class) &rest args)
(declare (ignore args))
- #'(lambda (location &optional (offset 0))
+ #'(lambda (location &optional (offset 0) weak-p)
+ (declare (ignore weak-p))
(let ((instance (sap-ref-sap location offset)))
(unless (null-pointer-p instance)
(ensure-proxy-instance class (reference-foreign class instance))))))
MAKE-PROXY-INSTANCE is called to create one."
(unless (null-pointer-p location)
(or
+ #-debug-ref-counting(find-cached-instance location)
+ #+debug-ref-counting
(let ((instance (find-cached-instance location)))
(when instance
(format t "Object found in cache: ~A~%" instance)
(apply #'make-proxy-instance (find-class class) location initargs))
(defmethod make-proxy-instance ((class proxy-class) location &key weak)
- (let ((instance (allocate-instance class)))
- (setf (slot-value instance 'location) location)
+ (let ((instance
+ (or
+ (find-invalidated-instance class)
+ (allocate-instance class))))
+ (setf (foreign-location instance) location)
(unless weak
(finalize instance (instance-finalizer instance)))
instance))
(defmethod unreference-foreign ((class struct-class) location)
(deallocate-memory location))
-(defmethod compute-foreign-size ((class struct-class))
- (let ((size (loop
- for slotd in (class-slots class)
- when (eq (slot-definition-allocation slotd) :alien)
- maximize (+
- (slot-definition-offset slotd)
- (size-of (slot-definition-type slotd))))))
- (+ size (mod size +struct-alignmen+))))
-
-(defmethod weak-reader-function ((class struct-class) &rest args)
+(defmethod compute-slots :around ((class struct-class))
+ (let ((slots (call-next-method)))
+ (when (and
+ #-sbcl>=0.9.8(class-finalized-p class) #+sbc098 t
+ (not (slot-boundp class 'size)))
+ (let ((size (loop
+ for slotd in slots
+ when (eq (slot-definition-allocation slotd) :alien)
+ maximize (+
+ (slot-definition-offset slotd)
+ (size-of (slot-definition-type slotd))))))
+ (setf (slot-value class 'size) (+ size (mod size +struct-alignmen+)))))
+ slots))
+
+(defmethod reader-function ((class struct-class) &rest args)
(declare (ignore args))
- #'(lambda (location &optional (offset 0))
+ #'(lambda (location &optional (offset 0) weak-p)
(let ((instance (sap-ref-sap location offset)))
(unless (null-pointer-p instance)
- (ensure-proxy-instance class instance :weak t)))))
+ (if weak-p
+ (ensure-proxy-instance class instance :weak t)
+ (ensure-proxy-instance class (reference-foreign class instance)))))))
(defclass static-struct-class (struct-class)
(declare (ignore class location))
nil)
+(defmethod reader-function ((class struct-class) &rest args)
+ (declare (ignore args))
+ #'(lambda (location &optional (offset 0) weak-p)
+ (declare (ignore weak-p))
+ (let ((instance (sap-ref-sap location offset)))
+ (unless (null-pointer-p instance)
+ (ensure-proxy-instance class instance :weak t)))))
+
;;; Pseudo type for structs which are inlined in other objects
(defmethod reader-function ((type (eql 'inlined)) &rest args)
(declare (ignore type))
(destructuring-bind (class) args
- #'(lambda (location &optional (offset 0))
+ #'(lambda (location &optional (offset 0) weak-p)
+ (declare (ignore weak-p))
(ensure-proxy-instance class
(reference-foreign class (sap+ location offset))))))
~mdw / clg / blobdiff