suzanne.soy/whalesong
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reducing juggling by a little more

Browse Source
This commit is contained in:
Danny Yoo 2012-03-01 17:22:18 -05:00
parent 05b1d9de86
commit c54583dde4
2 changed files with 68 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
compiler/compiler.rkt
View File

@ -1039,41 +1039,63 @@
(: compile-general-application (App CompileTimeEnvironment Target Linkage -> InstructionSequence)) (: compile-general-application (App CompileTimeEnvironment Target Linkage -> InstructionSequence))
(define (compile-general-application exp cenv target linkage) (define (compile-general-application exp cenv target linkage)
(let* ([extended-cenv (define n (length (App-operands exp)))
(extend-compile-time-environment/scratch-space (define extended-cenv (extend-compile-time-environment/scratch-space
cenv cenv
(length (App-operands exp)))] (length (App-operands exp))))
[proc-code (compile (App-operator exp) (define proc+operands-code
extended-cenv (cond
(if (empty? (App-operands exp)) ;; Optimization: if the operand and operands are all simple, we don't need to
'proc ;; juggle.
(make-EnvLexicalReference [(andmap simple-expression? (cons (App-operator exp) (App-operands exp)))
(ensure-natural (sub1 (length (App-operands exp)))) (define proc-code (compile (App-operator exp) extended-cenv 'proc next-linkage/expects-single))
#f)) (define operand-codes (map (lambda: ([operand : Expression]
next-linkage/expects-single)] [target : Target])
[operand-codes (map (lambda: ([operand : Expression] (compile operand
[target : Target]) extended-cenv
(compile operand target
extended-cenv next-linkage/expects-single))
target (App-operands exp)
next-linkage/expects-single)) (build-list (length (App-operands exp))
(App-operands exp) (lambda: ([i : Natural])
(build-list (length (App-operands exp)) (make-EnvLexicalReference i #f)))))
(lambda: ([i : Natural]) (apply append-instruction-sequences proc-code operand-codes)]
(if (< i (sub1 (length (App-operands exp)))) [else
(make-EnvLexicalReference i #f) ;; Otherwise, we need to juggle a little.
'val))))]) (define proc-code
(compile (App-operator exp)
extended-cenv
(if (empty? (App-operands exp))
'proc
(make-EnvLexicalReference
(ensure-natural (sub1 (length (App-operands exp))))
#f))
next-linkage/expects-single))
(define operand-codes
(map (lambda: ([operand : Expression]
[target : Target])
(compile operand
extended-cenv
target
next-linkage/expects-single))
(App-operands exp)
(build-list (length (App-operands exp))
(lambda: ([i : Natural])
(if (< i (sub1 (length (App-operands exp))))
(make-EnvLexicalReference i #f)
'val)))))
(append-instruction-sequences (append-instruction-sequences
(make-PushEnvironment (length (App-operands exp)) #f)
proc-code proc-code
(juggle-operands operand-codes) (juggle-operands operand-codes))]))
(make-AssignImmediate 'argcount
(make-Const (length (App-operands exp)))) (append-instruction-sequences
(compile-general-procedure-call cenv (make-PushEnvironment (length (App-operands exp)) #f)
(make-Const (length (App-operands exp))) proc+operands-code
target (make-AssignImmediate 'argcount (make-Const (length (App-operands exp))))
linkage)))) (compile-general-procedure-call cenv
(make-Const (length (App-operands exp)))
target
linkage)))
@ -1203,12 +1225,7 @@
(cond (cond
;; If all the arguments are primitive enough (all constants, localrefs, or toplevelrefs), ;; If all the arguments are primitive enough (all constants, localrefs, or toplevelrefs),
;; then application requires no stack space at all, and application is especially simple. ;; then application requires no stack space at all, and application is especially simple.
[(andmap (lambda (op) [(andmap simple-expression? (App-operands exp))
;; TODO: as long as the operand contains no applications?
(or (Constant? op)
(ToplevelRef? op)
(LocalRef? op)))
(App-operands exp))
(let* ([operand-knowledge (let* ([operand-knowledge
(map (lambda: ([arg : Expression]) (map (lambda: ([arg : Expression])
(extract-static-knowledge (extract-static-knowledge
@ -1334,6 +1351,17 @@
(error 'ensure-simple-expression))) (error 'ensure-simple-expression)))
(: simple-expression? (Expression -> Boolean))
;; Produces true if the expression is simple and constant.
;; TODO: generalize this so that it checks that the expression is
;; side-effect free. If it's side-effect free, then we can compute
;; the expressions in any order.
(define (simple-expression? e)
(or (Constant? e)
(LocalRef? e)
(ToplevelRef? e)))
(: simple-operands->opargs ((Listof Expression) (Listof CompileTimeEnvironmentEntry) -> (Listof OpArg))) (: simple-operands->opargs ((Listof Expression) (Listof CompileTimeEnvironmentEntry) -> (Listof OpArg)))
;; Produces a list of OpArgs if all the operands are particularly simple, and false otherwise. ;; Produces a list of OpArgs if all the operands are particularly simple, and false otherwise.
(define (simple-operands->opargs rands knowledge) (define (simple-operands->opargs rands knowledge)

2
version.rkt
View File

@ -7,4 +7,4 @@
(provide version) (provide version)
(: version String) (: version String)
(define version "1.204") (define version "1.205")