Re: alien use causes gratuitous GC

--- Raymond Toy <[email protected]> wrote:
> If it's not too large, could you just send the Lisp callback
routines?  
> That should give some hints on what's happening even if we don't have
> the foreign libraries.

I'll send what's manageable. I forgot one level of callback.  
It's actually: Lisp -> C -> Lisp -> C if you can believe it.

Here are the relevant alien definitions.

;; These are C functions called from the Lisp system of equations
function.
(def-alien-routine get_sysvar_n int)
(def-alien-routine get_sysvar_val double  (i int))
(def-alien-routine get_sysvar_dotval double  (i int))
(def-alien-routine set_sysvar_val void  (i int)  (x double))
(def-alien-routine set_sysvar_dotval void  (i int)  (x double))

;; these C functions are called once per complete simulation
(def-alien-routine init_dims void (nsys_var int)  (nparam int)
  ;; this registers the Lisp callback for the system of equations
  (model (* (function void (double-float)))))
(def-alien-routine mem_alloc int)
(def-alien-routine mem_free void)
(def-alien-routine fill_in int (start_time double)
  (init_vals (* double-float)) (sa int))
(def-alien-routine init_cvode void (init_vals (* double-float))
  (start_time double))
(def-alien-routine sim_model_cvode int
  (sample_time double))

The system of equations is built dynamically.  Slightly edited
code for this is included below and an example function is
given at the end of the email:
(defun cvode-make-MS-model (system sa?)
  `(progn
     ,(append 
        '(def-callback MS_model (void (time c-call:double)) 
	       (declare (optimize (speed 3) (safety 0))))
;; this adds some general Lisp code
       (assign-exo-vars (getv-exogenous-variables) 'time)
;; this adds Lisp code that calls C functions (see below)
       (cvode-assign-sys-vars)
;; this adds more Lisp code that calls some C functions
       (cvode-generate-f-equations system sa? t))))

;; this builds a part of the equations that calls C from
;; Lisp: get_sysvar_val(i), is a simple function that lets
;; Lisp access an array stored in C. 
(defun cvode-assign-sys-vars ()
  (let ((syslst))
    (dotimes (i (length *system-variables*) syslst)
      (push `(setf (aref *system-variables* ,i) 
		   (get_sysvar_val ,i))
	    syslst))))

;; here's the declaration of get_sysvar_val from above
double get_sysvar_val(int i) {return sys_var.vals[i];}

;; i call this function once for each of n variables for each 
;; explicit time step passed to the solver.  so, for one full
;; simulation, this function could be called hundreds of 
;; times.
;; here's a note that I wrote myself regarding Clisp that might
;; be helpful when thinking about CMUCL:
;;; when clisp calls the function get_sysvar_val, it allocates 16
;;; bytes of memory in which it stores the return value.  each call to
;;; get_sysvar_val grabs 16 more bytes, which can add up to a
;;; substantial amount of memory (and GC calls) during simulation.
;;; so, we duplicate the values of the system variables locally (i.e.,
in
;;; Lisp) to speed up access time and to avoid unnecessary garbage.

Finally, here is an example system of equations generated during
runtime.

(DEF-CALLBACK MS_MODEL
                  (VOID
                   (TIME
                     DOUBLE))
                  (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0)))
                  (SETF (AREF *SYSTEM-VARIABLES* 1) (GET_SYSVAR_VAL 1))
                  (SETF (AREF *SYSTEM-VARIABLES* 0) (GET_SYSVAR_VAL 0))
                  (SET_SYSVAR_DOTVAL 1
                                     (EQUATION-AGGREGATOR
                                      #<Function + {101AEC21}>
                                      (* -1.0d0
                                         (THE DOUBLE-FLOAT
                                              (AREF *MODEL-CONSTANTS*
3))
                                         (THE DOUBLE-FLOAT
                                              (AREF *SYSTEM-VARIABLES*
1))
                                         (THE DOUBLE-FLOAT
                                              (AREF *SYSTEM-VARIABLES*
0)))
                                      (*
                                       (THE DOUBLE-FLOAT
                                            (AREF *MODEL-CONSTANTS* 1))
                                       (THE DOUBLE-FLOAT
                                            (AREF *SYSTEM-VARIABLES*
1))
                                       (- 1
                                          (*
                                           (THE DOUBLE-FLOAT
                                                (AREF *MODEL-CONSTANTS*
0))
                                           (THE DOUBLE-FLOAT
                                                (AREF
*SYSTEM-VARIABLES*
                                                      1)))))))
                  (SET_SYSVAR_DOTVAL 0
                                     (EQUATION-AGGREGATOR
                                      #<Function + {101AEC21}>
                                      (*
                                       (THE DOUBLE-FLOAT
                                            (AREF *MODEL-CONSTANTS* 4))
                                       (THE DOUBLE-FLOAT
                                            (AREF *MODEL-CONSTANTS* 3))
                                       (THE DOUBLE-FLOAT
                                            (AREF *SYSTEM-VARIABLES*
1))
                                       (THE DOUBLE-FLOAT
                                            (AREF *SYSTEM-VARIABLES*
0)))
                                      (* -1.0d0
                                         (THE DOUBLE-FLOAT
                                              (AREF *MODEL-CONSTANTS*
2))
                                         (THE DOUBLE-FLOAT
                                              (AREF *SYSTEM-VARIABLES*
0))))))