home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 3: Developer Tools / Linux Cubed Series 3 - Developer Tools.iso / devel / lang / lisp / gcl-1.000 / gcl-1 / gcl-1.0 / doc / fast-link < prev    next >
Encoding:
Text File  |  1987-12-12  |  5.2 KB  |  159 lines
  1.     Description of Fast Link option for KCL
  2.  
  3. Author: Bill Schelter
  4.  
  5. When we refer to times of function calls, without other qualification,
  6. we will be referring to the simplest possible function of no args
  7. returning nil: (defun foo () nil).  This provides a good general indication
  8. of the timing of all functions.
  9.  
  10. The original KCL function calling system, distinguishes between
  11. functions defined in the same file, proclaimed functions, as well as
  12. having different calling mechanisms for different safety levels.
  13.  
  14. Some disadvantages were that calling across files always took at least
  15. 50mu, in spite of proclamations or safety.  Function calls inside a file
  16. either were fast (10 mu (or 3mu for proclaimed)) at safety 0 but incapable
  17. of being traced or redefined, or else as slow as cross file compilation.
  18.  
  19. We wished to have a scheme which would allow tracing and redefinition,
  20. of all calls, as well very fast calling.
  21.  
  22. In order to do this we set up links in the calls, and these are modified
  23. at the first call to the function, if the function is compiled.  Recompiling
  24. tracing, or redefining, undoes the link.
  25. (use-fast-links t) turns this feature on, and it is on by default.
  26. An argument of nil turns it off, so that all calls go through the function
  27. symbol.
  28.  
  29.  
  30. Some timings on the fast link compiling provided in this version of kcl.
  31.  
  32. FILEA:
  33. (proclaim '(optimize (safety 0)))
  34.  
  35. (proclaim '(function blue() t))
  36. (proclaim '(function blue1 (t) t))
  37. (proclaim '(function blue2 (t t) t))
  38. (proclaim '(function blue-same-file() t))
  39.  
  40. (defun test-blue (n)
  41.   (sloop for i below n do (blue)))
  42.  
  43. (defun test-blue1 (n)
  44.   (sloop for i below n do (blue1 nil)))
  45.  
  46. (defun test-blue2 (n)
  47.   (sloop for i below n do (blue2 nil nil)))
  48.  
  49. (defun test-blue-same-file (n)
  50.   (sloop for i below n do (blue-same-file)))
  51.  
  52. FILEB:
  53.  
  54. (defun blue () nil)
  55. (defun blue1 (x)x nil)
  56. (defun blue2 (x y) x y Compile and load FILEA then FILEB.
  57.  
  58. Timings:  We timed the invocation of blue,blue1, and blue2
  59. by executing the loops in fileA.  We subtracted the time for
  60. one empty loop iteration (2.7mu).
  61.  
  62.  
  63. Call                New                              Old
  64.  
  65. (blue)               3.03                            60.5
  66. (blue1 x)            4.1                             62.2                 
  67. (blue2 x y)          5.1                             64.3
  68. (blue-same-file)     3.03                             2.73
  69.  
  70. As can be seen all calls of blue are substantially speeded up, except
  71. for the calls in the same file, which are slightly slowed down.  There
  72. is however the advantage, that the calls in the same file can now be
  73. traced or redefined.  Also it is conceivable that the program might
  74. want to change a definition dynamically.  It is no longer necessary to
  75. recompile the whole file.  They are handled in exactly the same manner
  76. as the non local calls.
  77.  
  78. Since most software projects consist of more than one file, and
  79. since it is customary to move key routines to a basic files at
  80. the beginning of the system, we feel the importance of having fast
  81. calls across files is important.  For example in MAXIMA, there are
  82. 380 calls to ptimes, with naturally the large majority being in files
  83. other than the basic definition.  It is useful if the other calls
  84. can be made faster too.  Also when debugging some chunk of MAXIMA
  85. code, it is useful to be able to trace ptimes, without having to load
  86. in new definitions and recompile.  
  87.  
  88. Disadvantages:  The link table data takes up approximately 10 words,
  89. independent of the number of calls in a file to that function.
  90.  
  91.  
  92.  
  93. Space:  
  94. I made a file with 
  95.  
  96.  
  97. (defun try (a b) a b
  98.   (foos a b)(foos a b)(foos a b)(foos a b)(foos a b)
  99.   (foos a b)(foos a b)(foos a b)(foos a b)(foos a b)
  100.   (foos a b)(foos a b)(foos a b)(foos a b)(foos a b)
  101.   (foos a b)(foos a b)(foos a b)(foos a b)(foos a b)
  102.   (foos a b)(foos a b)(foos a b)(foos a b)(foos a b)
  103.   )
  104. I compared the size with various settings of *fast-link-compile*
  105. and with proclaiming foos.
  106. DIFF means the size above the case with all calls to FOOS removed.
  107.  
  108. text    data    bss    dec    DIFF  FLC    proclaimed     Case  SAMEFILE
  109. 1076    0    28    1104    836   nil      nil           I      nil
  110. 1308    0    32    1340    892   nil      nil           Ia     t
  111. 1296    4    28    1328    1060   t       nil           II     nil
  112. 1436    4    32    1472    1056   t       nil           IIa     t
  113. 684    4    28    716    448    t        t            III    nil
  114. 244    0    24    268    0      t   ; calls removed.  IV     nil
  115. 384    0    32    416    0      nil ;cals removed     V      t
  116.  
  117.  
  118.  
  119. The reason II is bigger than I is that the vs_top and vs_base settings
  120. are being performed in the file, in exactly the same manner as if the 
  121. definition for foos were in the file.  FLC=nil with definition of foos
  122. in the same file would also be higher.  Should probably have a type
  123. of proclamation which would favor the case I call in cases where speed
  124. is irrelevant.  But then why not go with III..  
  125.  
  126.  
  127. Appendix:
  128. Notes: 
  129. 1)Empty loop takes 2.70 seconds for 1,000,000 iterations.
  130. 2)blue-same-file or blue 
  131.  
  132. >(time (test-blue 1000000))
  133. real time : 5.750 secs
  134. run time  : 5.733 secs
  135. NIL
  136.  
  137. >(trace blue)
  138. (BLUE)
  139.  
  140. >(test-blue 2)
  141.   1> (BLUE)
  142.   <1 (BLUE NIL)
  143.   1> (BLUE)
  144.   <1 (BLUE NIL)
  145. NIL
  146.  
  147. >(trace blue-same-file)
  148. (BLUE-SAME-FILE)
  149.  
  150. >(test-blue-same-file 2)
  151.   1> (BLUE-SAME-FILE)
  152.   <1 (BLUE-SAME-FILE NIL)
  153.   1> (BLUE-SAME-FILE)
  154.   <1 (BLUE-SAME-FILE NIL)
  155. NIL
  156.  
  157.  
  158.  
  159.