文字列検索アルゴリズムBM法，KMP法，力任せに関する疑問

Question

以下のプログラムは，タイトルの3つの手法で検索したときにどのくらいの時間がかかったのかと，検索マッチ場所を返し，csvとして出力するコードです．
検索文字列が1文字のときには，力任せが処理が少なく，最高速となるという予想でしたが，KMPに負けてしまいました．
キャッシュが原因なのでしょうか？ それとも，ソースがおかしいのでしょうか？
それとも，スライスを利用したことが原因でしょうか？
困惑しています． 助けてください．
追伸 長いソースでごめんなさい． また，ソースこう直した方がいいみたいのがあれば教えていただけると嬉しいです．

// ssearch project main.go
package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"ssearch/bm"
	"ssearch/kmp"
	"ssearch/simple"
	"strconv"
	"time"
)

var filename []string = []string{
	"testin.txt",
	"The Golden Link of Friendship.txt",
	"The Great Round World and What Is Going On In It, Vol. 1, No. 28, May 20, 1897.txt",
	"Fishing and Shooting Sketches.txt",
	"Take the Reason Prisoner.txt",
	"Jack Hardy.txt",
	"Dorothy's Mystical Adventures in Oz.txt",
	"My Lady Peggy Goes to Town.txt",
	"A Little Girl in Old Quebec.txt",
	"Cuore (Heart).txt",
	"The Argentine Republic.txt",
	"The Great Conspiracy, Complete.txt",
}

const try_times = 1000

func out_result(r_file string, file_size int, process_time float64, result []int) string {
	var out_string string
	//読み込みファイル名，バイト数，実行時間(ms)，適合個数，適合個所
	out_string = "\"" + r_file + "\"" + "," + strconv.Itoa(file_size) + "," + strconv.FormatFloat(process_time, 'f', 4, 64) + "," + strconv.Itoa(len(result)) + ","
	for _, val := range result {
		out_string += strconv.Itoa(val) + ","
	}
	return out_string
}
func out_file(file_name string, str []string) {
	var output string
	for _, val := range str {
		output += val + "\n"
	}
	ioutil.WriteFile(file_name, []byte(output), os.ModePerm)
}

func main() {
	var simp_str, kmp_str, bm_str []string
	var simp_res, kmp_res, bm_res []int
	//scanner := bufio.NewScanner(os.Stdin)
	path := make([]string, len(filename))
	for i := 0; i < len(path); i++ {
		path[i] = "./corpus/" + filename[i]
	}

	for file_id, _ := range filename {
		buff, err := ioutil.ReadFile(path[file_id])
		if err != nil {
			fmt.Fprintln(os.Stderr, err)
			os.Exit(1)
		}

		data := string(buff)

		key := "it must be"
		{
			start := time.Now()
			for i := 0; i < try_times; i++ {
				simp_res = simple.Search(data, key)
			}
			end := time.Now()
			process_time := (end.Sub(start).Seconds() * 1000) / try_times
			simp_str = append(simp_str, out_result(filename[file_id], len(data), process_time, simp_res))
		}
		{
			start := time.Now()
			for i := 0; i < try_times; i++ {
				bm_res = bm.Search(data, key)
			}
			end := time.Now()
			process_time := (end.Sub(start).Seconds() * 1000) / try_times
			bm_str = append(bm_str, out_result(filename[file_id], len(data), process_time, bm_res))
		}
		{
			start := time.Now()
			for i := 0; i < try_times; i++ {
				kmp_res = kmp.Search(data, key)
			}
			end := time.Now()
			process_time := (end.Sub(start).Seconds() * 1000) / try_times
			kmp_str = append(kmp_str, out_result(filename[file_id], len(data), process_time, kmp_res))
		}
	}
	out_file("simp.csv", simp_str)
	out_file("bm.csv", bm_str)
	out_file("kmp.csv", kmp_str)

}

package kmp

var skip []int

func init_skip(key string) {
	skip = make([]int, len(key))
	skip[0] = 1

	for pos := 1; pos < len(key); pos++ {
		var k int
		for k = 1; k < pos; k++ {
			var m int
			for m = k; m < pos && key[m] == key[m-k]; m++ {
			}
			if m == pos {
				break
			}
		}
		skip[pos] = k
	}
}

func Search(data, key string) (match_position []int) {
	init_skip(key)

	for kpos, pos := 0, 0; pos < len(data); {
		if key[kpos] == data[pos] {
			if kpos == len(key)-1 {
				match_position = append(match_position, pos-len(key)+1)
				kpos = 0
			} else {
				kpos++
			}
			pos++
		} else {
			if kpos == 0 {
				pos++
			} else {
				kpos -= skip[kpos]
			}
		}

	}
	return
}

package bm

var skip [256]int

func init_skip(key string) {

	for pos := 0; pos < len(key)-1; pos++ {
		skip[key[pos]] = len(key) - pos - 1
	}
	for pos := 0; pos < len(skip); pos++ {
		if skip[pos] == 0 {
			skip[pos] = len(key)
		}
	}
}

func Search(data, key string) (match_position []int) {
	init_skip(key)

	for kpos, pos := 0, 0; pos <= len(data)-len(key); {
		var dpos int = pos + len(key)
		for kpos = len(key) - 1; kpos >= 0; kpos-- {
			dpos -= 1
			if data[dpos] != key[kpos] {
				break
			} else if kpos == 0 {
				match_position = append(match_position, dpos)
			}
		}
		pos += skip[data[dpos]]
	}

	return
}

package simple

func Search(data, key string) (match_position []int) {
	for kpos, dpos := 0, 0; dpos <= len(data)-len(key); dpos++ {
		match := true
		for kpos = 0; kpos < len(key); kpos++ {
			if data[dpos+kpos] != key[kpos] {
				match = false
				break
			}
		}
		if match == true {
			match_position = append(match_position, dpos)
		}
	}
	return
}

Answer 1

simple search で無駄にbool型使ってたのがよくなかったみたいです．(´･ω･｀)