anchor.diff:        (iter (for object in-vector others)
   	    (#_delete object)))))
   
  -(defun bench-call-parent/naive (&optional (repeat *repeat*))
  +(defun bench-interpret-new-qobject (&optional (repeat *repeat*))
  +  (let ((objects (make-array repeat)))
  +    (prog1
  +	(measure-dotimes (x repeat)
  +	  (setf (elt objects x) (interpret-new "QObject")))
  +      (iter (for object in-vector objects)
  +	    (#_delete object)))))
  +
  +(defun bench-interpret-new-qcolor (&optional (repeat *repeat*))
  +  (let ((objects (make-array repeat)))
  +    (prog1
  +	(measure-dotimes (x repeat)
  +	  (setf (elt objects x) (interpret-new "QColor")))
  +      (iter (for object in-vector objects)
  +	    (#_delete object)))))
  +
  +(defun bench-interpret-new-qcolor/3 (&optional (repeat *repeat*))
  +  (let ((objects (make-array repeat)))
  +    (prog1
  +	(measure-dotimes (x repeat)
  +	  (setf (elt objects x) (interpret-new "QColor" #xca #xfe #xba)))
  +      (iter (for object in-vector objects)
  +	    (#_delete object)))))
  +
  +(defun bench-interpret-new-qcolor/4 (&optional (repeat *repeat*))
  +  (let ((objects (make-array repeat)))
  +    (prog1
  +	(measure-dotimes (x repeat)
  +	  (setf (elt objects x) (interpret-new "QColor" #xca #xfe #xba #xbe)))
  +      (iter (for object in-vector objects)
  +	    (#_delete object)))))
  +
  +(defun bench-interpret-delete-qobject (&optional (repeat *repeat*))
  +  (let ((objects (make-array repeat)))
  +    (dotimes (i repeat)
  +      (setf (elt objects i)
  +	    (#_new QObject)))
  +    (measure-dotimes (i repeat)
  +      (interpret-delete (elt objects i)))))
  +
  +(defun bench-interpret-call-parent (&optional (repeat *repeat*))
     (measure-on-qobjects (lambda (objects i)
   			 (interpret-call (elt objects i) "parent"))
   		       repeat))
  +
  +(defun bench-interpret-call-setparent0 (&optional (repeat *repeat*))
  +  (let ((x (null-qobject (find-qclass "QObject"))))
  +    (measure-on-qobjects (lambda (objects i)
  +			   (interpret-call (elt objects i) "setParent" x))
  +			 repeat)))
  +
  +(defun bench-interpret-call-setparent (&optional (repeat *repeat*))
  +  (let ((others (make-array repeat)))
  +    (dotimes (i repeat)
  +      (setf (elt others i)
  +	    (#_new QObject)))
  +    (prog1
  +	(measure-on-qobjects (lambda (objects i)
  +			       (interpret-call (elt objects i)
  +					       "setParent"
  +					       (elt others i)))
  +			     repeat)
  +      (iter (for object in-vector others)
  +	    (#_delete object)))))
   
   (defun bench/nop (&optional (repeat *repeat*))
     (measure-on-qobjects (lambda (objects i)
  
positive.code:     (let ((*standard-output* (make-broadcast-stream *standard-output* s))
  	  (*repeat* (choose-repeat-count)))
        (format s ":repeat-count ~D~%" *repeat*)
        (ensure-smoke :qtcore)
        (ensure-smoke :qtgui)
        (init/cffi)
        (format s ":results (~%")
        (dolist (fun '(bench/nop
  
negative.code: 		  (software-type)
  		  (software-version))))
  
  (defun choose-repeat-count (&optional (fun 'bench-call-parent)
  			              (seconds-for-a-test 2))
    ;; run the call-parent microbench for at least a second to estimate
    ;; implementation speed, then choose a good iteration count based on that.
    (let* ((total-time 0)
  	 (niterations 0)
  	 (1s 1e9)
  	 (good-time-for-a-test (* seconds-for-a-test 1s)))
      (iter (until (> total-time 1s))
  	  (incf total-time
  		(measure-dotimes (dummy 1)
  		  (let ((arbitrary-number 1000))
  		    (funcall fun arbitrary-number)
  		    (incf niterations arbitrary-number)))))
      (ceiling (* niterations (/ good-time-for-a-test total-time)))))
  
  