Subversion Repositories openrisc

// Copyright 2009 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

// This file prints execution times for the Mul benchmark

// given different Karatsuba thresholds. The result may be

// used to manually fine-tune the threshold constant. The

// results are somewhat fragile; use repeated runs to get

// a clear picture.

// Usage: gotest -calibrate

package big

import (

        "flag"

        "fmt"

        "testing"

        "time"

)

var calibrate = flag.Bool("calibrate", false, "run calibration test")

// measure returns the time to run f

func measure(f func()) time.Duration {

        const N = 100

        start := time.Now()

        for i := N; i > 0; i-- {

                f()

        }

        stop := time.Now()

        return stop.Sub(start) / N

}

func computeThresholds() {

        fmt.Printf("Multiplication times for varying Karatsuba thresholds\n")

        fmt.Printf("(run repeatedly for good results)\n")

        // determine Tk, the work load execution time using basic multiplication

        karatsubaThreshold = 1e9 // disable karatsuba

        Tb := measure(benchmarkMulLoad)

        fmt.Printf("Tb = %dns\n", Tb)

        // thresholds

        n := 8 // any lower values for the threshold lead to very slow multiplies

        th1 := -1

        th2 := -1

        var deltaOld time.Duration

        for count := -1; count != 0; count-- {

                // determine Tk, the work load execution time using Karatsuba multiplication

                karatsubaThreshold = n // enable karatsuba

                Tk := measure(benchmarkMulLoad)

                // improvement over Tb

                delta := (Tb - Tk) * 100 / Tb

                fmt.Printf("n = %3d  Tk = %8dns  %4d%%", n, Tk, delta)

                // determine break-even point

                if Tk < Tb && th1 < 0 {

                        th1 = n

                        fmt.Print("  break-even point")

                }

                // determine diminishing return

                if 0 < delta && delta < deltaOld && th2 < 0 {

                        th2 = n

                        fmt.Print("  diminishing return")

                }

                deltaOld = delta

                fmt.Println()

                // trigger counter

                if th1 >= 0 && th2 >= 0 && count < 0 {

                        count = 20 // this many extra measurements after we got both thresholds

                }

                n++

        }

}

func TestCalibrate(t *testing.T) {

        if *calibrate {

                computeThresholds()

        }

}