anchor.diff:    (make-pathname :directory `(:relative ,(filesys-escape-name
                                             (md5-pathname-component
                                              (prin1-to-string implementations)))
  -                                        ,host
  +                                        ,(filesys-escape-name
  +                                          (md5-pathname-component
  +                                           (prin1-to-string host)))
                                           ,(if only-release only-release "all"))
                    :name (filesys-escape-name benchmark)))
   
   (defun make-offset-table (&rest conditions)
     (let ((table (make-hash-table :test #'equal)))
       (values table
  -            (iterate (for (impl) in-relation
  +            (iterate (for (impl host) in-relation
                     (translate*
  -                   `(distinct (select ((++ b.v-name "," b.mode))
  +                   `(distinct (select ((++ b.v-name "," b.mode) r.m-name)
                                         (order-by
                                          ,(apply #'emit-where-clause conditions)
                                          ((++ b.v-name "," b.mode)) :desc))))
                     on-connection *dbconn*)
                (for offset from 0)
                (maximizing offset)
  -             (setf (gethash impl table) offset)))))
  +             (setf (gethash (list impl host) table) offset)))))
   
   (defun ploticus-offset-args (offset-table)
  -  (iterate (for (impl offset) in-hashtable offset-table)
  +  (iterate (for ((impl host) offset) in-hashtable offset-table)
              (for pl-s = (if (= offset 0) "" (+ 2 (truncate offset 2))))
              ;; "name=SBCL" "y=2" "err=3" "name2=CMU Common Lisp" "y2=4" "err2=5"
  -           (collect (format nil "name~A=~A" pl-s (pprint-impl-and-mode impl)))
  +           (collect (format nil "name~A=~A/~A" pl-s host (pprint-impl-and-mode impl)))
              (collect (format nil "y~A=~A" pl-s (+ 2 (* 2 offset))))
              (collect (format nil "err~A=~A" pl-s (+ 3 (* 2 offset))))))
   
   (defun generate-image-for (&rest conditions &key unit &allow-other-keys)
  +  (declare (optimize (speed 0) (space 0)
  +                     (debug 2)))
     (multiple-value-bind (offset-table max-offset) (apply #'make-offset-table conditions)
       (let ((filename (merge-pathnames (apply #'file-name-for conditions) *prefab-base*)))
   
         (with-open-file (f (ensure-directories-exist filename) :direction :output
                            :if-exists :supersede :if-does-not-exist :create)
  -        (iterate (for (date name version mean stderr) in-relation
  -                      (translate* `(select (v.release-date (++ b.v-name "," b.mode) v.version
  +        (iterate (for (date host name version mean stderr) in-relation
  +                      (translate* `(select (v.release-date r.m-name (++ b.v-name "," b.mode) v.version
                                                              (avg r.seconds) (/ (stddev r.seconds) (sqrt (count r.seconds))))
                                              (order-by
                                               (group-by ,(apply #'emit-where-clause conditions)
  -                                                      (v.release-date (++ b.v-name "," b.mode) v.version))
  +                                                      (v.release-date r.m-name (++ b.v-name "," b.mode) v.version))
                                               (v.release-date))))
                         on-connection *dbconn*)
  -                 (for offset = (gethash name offset-table))
  +                 (for offset = (gethash (list name host) offset-table))
                    (format f "~A~A~f~A~f~A~%"
                            version
                            (make-string (1+ (* 2 offset)) :initial-element #\Tab)
  
positive.code:                                                                         (where
                                                                           (join result benchmark
                                                                                 :on (= result.b_name benchmark.name))
                                                                           (= result.m-name ,host)))))) :tuples))
           (date-boundaries (apply #'date-boundaries args))
           (earliest (first date-boundaries))
           (latest (second date-boundaries)))
  
negative.code:                                                    :on (and (= result.m-name machine-support.m-name)
                                                              (= result.v-name machine-support.i-name)
                                                              (= result.mode machine-support.mode)))
                                               (and (in result.m-name ',host)
                                                    ,@(if preferred-only
                                                          '(preferred)
                                                          nil))))))
  