1 / 25

Functional Programming

11 Speed & Debug. Functional Programming. Speed - Introduction. Lisp is really two languages: A language for writing fast programs A language for writing programs fast

meryle
Download Presentation

Functional Programming

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 11 Speed & Debug Functional Programming

  2. Speed - Introduction • Lisp is really two languages: • A language for writing fast programs • A language for writing programs fast • In the early stage, you can trade speed for convenience. Then, you can refine critical portions to make them faster once your program begins to crystallize

  3. Speed - The Bottleneck Rule • Optimization • Should be focused on bottlenecks • Should not begin too early • Should begin with algorithms • Programs tend to have a few bottlenecks that account for a great part of the execution time • “Most of the running time in none-IO-bound programs is concentrated in about 3% of the source text. Optimizing these parts of the program will make it run noticeably faster; optimizing the rest of the program will be a waste of time on comparison.”, by Knuth

  4. Speed - The Bottleneck Rule • Optimize the program from the top • Make sure that you’re using the most efficient algorithm before you resort to low-level coding tricks • Decisions about algorithms have to be made early

  5. Speed - Compilation • Five parameters control the way your code is compiled • Speed: the speed of the code produced by the compiler • Compilation-speed: the speed at which your program will be compiled • Safety: the amount of error-checking done in the object code • Space: the size and memory needs of the object code • Debug: the amount of information retained for debugging

  6. Speed - Compilation • The compilation parameters are not real variables. They are assigned weights from 0 (unimportant) to 3 (most important) in declarations • (defunbottlenect (…) (do (…) (…) (do (…) (…) (declare (optimize (speed 3) (safety 0))) …))) • Add such declarations until the code was finished and tested

  7. Speed - Compilation • Inline function • Without the cost of calling functions • Similar to macros • Macro • Since macros use mere textual substitution, this may result in unintended side-effects and inefficiency due to re-evaluation of arguments and order of operations • Compiler errors within macros are often difficult to understand, because they refer to the expanded code • Recursive functions cannot be inlined • If an inlined function is redefined, we have to recompile any function that calls it

  8. Speed - Compilation • (declaim(inline single?))(defun single? (lst) (and (consplst) (null (cdrlst)))) • (defunfoo (x) (single? (bar x))) • When foo is compiled(defunfoo (x) (let ((lst (bar x))) (and (consplst) (null (cdrlst)))))

  9. Speed - Type Declarations • In most languages, you have to declare the type of each variable, and the variable can only hold values of that type → strongly typed language • Common List uses manifest typing (run-time typing) • Type information is attached to the data objects • Type information is used at run-time • Variables can hold objects of any type • We have to pay for this flexibility in speed • The function have to look at the types of each of its arguments at run-time • If we just want one type, say, fixnum, this is an inefficient way

  10. Type Declarations • In Common Lisp, type declarations are completely optional • Global declarations are made with declaim • (declaim (typefixnum *count*)) ;type can be omitted • Local declarations are made with declare • (defun poly (a b x) (declare (fixnum a b x)) (+ (* a (expt x 2)) (* b x)))

  11. Type Declarations • Type declarations are particularly important for the contents of complex objects, including arrays and structures • Declarations can improve efficiencyThe compiler can determine the types of arguments to functions and represent these objects more efficients • If nothing is known about the type of elements an array will contain, it has to be represented in memory as a block of pointers • If it is known that the array will only contain, say, double-floats, then the array can be represented as a block of actual double-floats

  12. Type Declarations • (setf x (vector 1.234d0 2.345d0 3.456d0) y (make-array 3 :element-type ‘double-float) (aref y 0) 1.234d0 (aref y 1) 2.345d0 (aref y 2) 3.456d0)

  13. Speed - Type Declarations • (setf a (make-array ‘(1000 1000) :element-type ‘single-float :initial-element 1.0))(defunsim-elts (a) (declare (type (simple-array single-float (1000 1000)) a)) (let ((sum 0.0)) (declare (type single-float sum)) (dotimes (r 1000) (dotimes (c 1000) (incf sum (aref a r c)))) sum))

  14. Speed - Type Declarations • > (compile-file “..\\test\\declare.lsp”) • > (load “..\\test\\declare.fas”) • > (time (sum-elts a)) Real time: 0.823 sec. Run time: 0.8112052 sec. Space: 11999988 Bytes GC: 1, GC time: 0.1092007 sec. 1000000.0 • > (compile-file “..\\test\\nodeclare.lsp”) • > (load “..\\test\\nodeclare.fas”) • > (time (sum-elts-nodeclare a))Real time: 1.026 sec. Run time: 0.9984064 sec. Space: 11999988 Bytes GC: 2, GC time: 0.2340015 sec. 1000000.0

  15. Speed - Garbage Avoidance • Dynamic allocation is slow • Programs that cons a lot tend to run slowly in Lisp implementations with bad garbage collectors • Until recently, most Lisp implementations have had bad garbage collectors • Efficient programs should cons as little as possible

  16. Speed - Garbage Avoidance • One of the easiest way is to use destructive functions • When you know it’s safe to modify a list, you can use delete instead of remove, nreverse instead of reverse, and so on

  17. Speed - Garbage Avoidance • Use a pre-allocated vector instead of building it using conses • > (setf *print-array* t)T> (setfvec (make-array 10 :fill-pointer 2 :initial-element nil))#(NIL NIL)> (length vec)2> (vector-push ‘a vec)2> vec#(NIL NIL A)> (vector-pop vec)A> vec#(NIL NIL)

  18. Speed – Fast Operators • svref is more efficient than aref • eq is more efficient than eql • (reduce #’+ ‘(1 2 3)) is more efficient than (apply #’+ ‘(1 2 3))

  19. Debug • trace • (defun count-atoms (expression) (if (atom expression) 1 (+ (count-atoms (first expression)) (count-atoms (rest expresstion))))) • > (count-atoms ‘((this is) (a test)))7 ;we expect 4

  20. Debug • > (trace count-atoms);; Tracing function COUNT-ATOMS. (COUNT-ATOMS) • (count-atoms '((this is) (a test)))

  21. Debug • 4. Trace: (COUNT-ATOMS '(A TEST)) • 5. Trace: (COUNT-ATOMS 'A) • 5. Trace: COUNT-ATOMS ==> 1 • 5. Trace: (COUNT-ATOMS '(TEST)) • 6. Trace: (COUNT-ATOMS 'TEST) • 6. Trace: COUNT-ATOMS ==> 1 • 6. Trace: (COUNT-ATOMS 'NIL) • 6. Trace: COUNT-ATOMS ==> 1 • 5. Trace: COUNT-ATOMS ==> 2 • 4. Trace: COUNT-ATOMS ==> 3 • 4. Trace: (COUNT-ATOMS 'NIL) • 4. Trace: COUNT-ATOMS ==> 1 • 3. Trace: COUNT-ATOMS ==> 4 • 2. Trace: COUNT-ATOMS ==> 7 • 7 2. Trace: (COUNT-ATOMS '((THIS IS) (A TEST))) 3. Trace: (COUNT-ATOMS '(THIS IS)) 4. Trace: (COUNT-ATOMS 'THIS) 4. Trace: COUNT-ATOMS ==> 1 4. Trace: (COUNT-ATOMS '(IS)) 5. Trace: (COUNT-ATOMS 'IS) 5. Trace: COUNT-ATOMS ==> 1 5. Trace: (COUNT-ATOMS 'NIL) 5. Trace: COUNT-ATOMS ==> 1 4. Trace: COUNT-ATOMS ==> 2 3. Trace: COUNT-ATOMS ==> 3 3. Trace: (COUNT-ATOMS '((A TEST)))

  22. Debug • (defun count-atoms (expression) (cond ((atom expression) 1) ((null expression) 0) (t (+ (count-atoms (first expression)) (count-atoms (rest expression)))))) • > (count-atoms ‘((this is) (a test)))7

  23. Debug • (defun count-atoms (expression) (cond ((null expression) 0) ((atom expression) 1) (t (+ (count-atoms (first expression)) (count-atoms (rest expression)))))) • > (count-atoms ‘((this is) (a test)))4 • > (untrace count-atoms)

  24. Debug • > (dribble “record.txt”) ;記錄在toplevel的過程……> (dribble) ;stop dribbling • > (ed “record.txt”)

  25. Final Projects • Write a Lisp program with at least 15 functions • Due June 30 • Report • Source code • Demo

More Related