Alloc = 28 MiB  TotalAlloc = 199 MiB    Sys = 60 MiB    NumGC = 30
PASS
ok      _/home/senseye/develop/projects/BigSort 4.806s

Alloc = 151 MiB TotalAlloc = 976 MiB    Sys = 299 MiB   NumGC = 43
PASS
ok      _/home/senseye/develop/projects/BigSort 25.129s

package bigsort

import (
    "bufio"
    "fmt"
    "math/rand"
    "os"
    "runtime"
    "sort"
    "strconv"
    "strings"
    "testing"
)

type (
    item struct {
        member int
        score  int
    }
)

const (
    sourceFileName      = "source.csv"
    destinationFileName = "destination.csv"
    size                = 1e6
)

func Test(t *testing.T) {
    err := fillFileOnce(sourceFileName, size)
    assertSuccess(t, err)

    err = sortAndStore(sourceFileName, destinationFileName)
    assertSuccess(t, err)

    printMemUsage()
}

func assertSuccess(t *testing.T, err error) {
    if err != nil {
        t.Fatal("Expect success, but got:", err)
    }
}

func fillFileOnce(fileName string, count int) error {
    if f, err := os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY, 0600); err == nil {
        f.Close()

        return nil
    }

    f, err := os.Create(fileName)
    if err != nil {
        return err
    }
    f.Close()

    f, err = os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY, 0600)
    if err != nil {
        return err
    }
    defer f.Close()

    perm := rand.Perm(count)
    for i, v := range perm {
        f.Write([]byte(fmt.Sprintf("%d,%d\n", i, v)))
    }

    return nil
}

func sortAndStore(sourceFileName, destinationFileName string) error {
    if f, err := os.OpenFile(destinationFileName, os.O_APPEND|os.O_WRONLY, 0600); err == nil {
        f.Close()

        return nil
    }

    sourceFile, err := os.OpenFile(sourceFileName, os.O_RDONLY, 0600)
    if err != nil {
        return err
    }
    defer sourceFile.Close()

    f, err := os.Create(destinationFileName)
    if err != nil {
        return err
    }
    f.Close()

    destinationFile, err := os.OpenFile(destinationFileName, os.O_APPEND|os.O_WRONLY, 0600)
    if err != nil {
        return err
    }
    defer destinationFile.Close()

    items := make([]item, 0)
    scanner := bufio.NewScanner(sourceFile)
    for scanner.Scan() {
        parts := strings.Split(scanner.Text(), ",")

        items = append(items, item{
            member: parseInt(parts[0]),
            score:  parseInt(parts[1]),
        })
    }

    sort.Slice(items, func(i, j int) bool { return items[i].score < items[j].score })

    for i := range items {
        destinationFile.Write([]byte(fmt.Sprintf("%d,%d\n", items[i].member, items[i].score)))
    }

    return nil
}

func parseInt(s string) int {
    r, _ := strconv.Atoi(s)

    return r
}

func printMemUsage() {
    var m runtime.MemStats
    runtime.ReadMemStats(&m)
    // For info on each, see: https://golang.org/pkg/runtime/#MemStats
    fmt.Printf("Alloc = %v MiB", bToMb(m.Alloc))
    fmt.Printf("\tTotalAlloc = %v MiB", bToMb(m.TotalAlloc))
    fmt.Printf("\tSys = %v MiB", bToMb(m.Sys))
    fmt.Printf("\tNumGC = %v\n", m.NumGC)
}

func bToMb(b uint64) uint64 {
    return b / 1024 / 1024
}