Return to optimize CVS log

Up to [Research Unix] / researchv10no / cmd / sml / doc

Annotation of researchv10no/cmd/sml/doc/optimize, revision 1.1

1.1     ! root        1:                How to Standard ML of New Jersey run faster
        !             2: 
        !             3: 
        !             4: 1. Each compilation unit is compiled separately.  None of the 
        !             5:    optimizations take place across compilation-unit boundaries.   
        !             6:    Example:
        !             7: 
        !             8:        fun f(x) = (x,x);
        !             9:         fun g 0 = nil | g i = f i :: g(i-1);
        !            10:         
        !            11:    This is two compilation units if typed at top level, or if loaded
        !            12:    from a file because at the first semicolon, the function f is compiled,
        !            13:    and then at the next semicolon, g is compiled.  The function g will run
        !            14:    significantly faster if any of the following is used instead:
        !            15: 
        !            16:        fun f(x) = (x,x)
        !            17:         fun g 0 = nil | g i = f i :: g(i-1);
        !            18: 
        !            19:        local fun f(x) = (x,x);
        !            20:           in  fun g 0 = nil | g i = f i :: g(i-1)
        !            21:          end;
        !            22: 
        !            23:     structure S = struct 
        !            24:        fun f(x) = (x,x);
        !            25:         fun g 0 = nil | g i = f i :: g(i-1);
        !            26:      end;
        !            27: 
        !            28:     In either of these last two, of course, the semicolons are optional.
        !            29: 
        !            30:     Moral of the story:  use small compilation units while typing to
        !            31:     the interactive system and seeing how things work.  Use larger
        !            32:     compilation units when compiling large programs.  I recommend the
        !            33:     use of the module system, or of "let" and "local" declarations,
        !            34:     to bind things together in a well-structured way.
        !            35: 
        !            36:     The use of signature constraints to minimize the number of things
        !            37:     exported from structures will reduce memory usage, and is just clean style.
        !            38: 
        !            39: 2.  For the fanatic:  (these are not guaranteed forever)
        !            40: 
        !            41:        The initial environment (i.e. the List, Array, Ref, etc. structures)
        !            42:     is normally in a separate module from the user program.  If you
        !            43:     would like a copy of this stuff in your program so that calls to the
        !            44:     pervasive functions will have less overhead, textually insert
        !            45:     src/boot/fastlib.sml near the beginning of your own structure.
        !            46:     This only helps, of course, if fastlib.sml is put into the same
        !            47:     compilation unit as the functions calling it, using the module
        !            48:     system as described above.
        !            49: 
        !            50:        You can nest structures.  To get better performance, after you
        !            51:     have developed your program, nest the whole thing in one huge
        !            52:     structure, e.g.
        !            53: 
        !            54:        structure Whole : sig end = struct
        !            55: 
        !            56:                your program
        !            57:        end
        !            58: 
        !            59:     You can even put signatures and functors at top level inside such a
        !            60:     structure, although this is not "Standard" ML.
        !            61: 
        !            62: 
        !            63: 3.  You can increase the level of optimization, if you want to wait
        !            64:     a bit longer for compiles.  To make things compile more slowly
        !            65:     but run faster, execute this before compiling your program:
        !            66: 
        !            67:        System.Control.CG.reducemore := 0;
        !            68:        System.Control.CG.rounds := 10;
        !            69:        System.Control.CG.bodysize := 20;
        !            70: 
        !            71:     To make things compile faster but run slower, try this:
        !            72: 
        !            73:        System.Control.CG.reducemore := 10000;
        !            74:        System.Control.CG.rounds := 0;
        !            75:        System.Control.CG.bodysize := ~100;
        !            76:        System.Control.CG.reduce := false;
        !            77: 
        !            78: 4.  You can measure the execution time of your programs using the
        !            79:     functions in System.Timer.
        !            80:     (* in the initial environment,
        !            81:        signature TIMER =
        !            82:          sig  
        !            83:            datatype time = TIME of {sec : int, usec : int}
        !            84:            type timer
        !            85:            val start_timer : unit -> timer
        !            86:            val check_timer : timer -> time
        !            87:            val check_timer_gc: timer -> time
        !            88:            val makestring : time -> string
        !            89:            val add_time : time * time -> time
        !            90:          end
        !            91:         structure System.Timer : TIMER 
        !            92:      *)
        !            93: 
        !            94:       let val t = System.Timer.start_timer()
        !            95:           val _ = run_my_program()
        !            96:           val non_gc_time = System.Timer.check_timer t
        !            97:           val gc_time = System.Timer.check_timer_gc t
        !            98:           val total_time = System.Timer.add_time(non_gc_time,gc_time)
        !            99:        in print(System.Timer.makestring total_time)
        !           100:       end
        !           101: 
        !           102: 5.  You can also use the execution profiler, described in doc/profiling

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.