Fix tilebuilder bug when looking for start time.

perf/server/src/tilebuilder/main.go

 // tilebuilder is an application that periodically loads new data from BigQuery
 // for quick and easy consumption by the skiaperf UI.
 //
 //  The algorithm
 //  -------------
 //
 //  Start at level 0.
 //  Find the index of the last tile (0000.gob, 0001.gob, etc)
 //  nextTile = (last tile)+1 or 0 if no tiles were found.
 //  Find the last commit time from the last tile file, or use BEGINNING_OF_TIME if there were no tile files.
@@ skipping 20 matching lines @@
 //  }}
 //
 package main
 
 import (
         "bytes"
         "flag"
         "fmt"
         "net"
         "net/http"
+        "sort"
         "text/template"
         "time"
 )
 
 import (
         "code.google.com/p/goauth2/compute/serviceaccount"
         "code.google.com/p/google-api-go-client/bigquery/v2"
         "github.com/golang/glog"
         "github.com/rcrowley/go-metrics"
 )
@@ skipping 96 matching lines @@
         if tile != nil {
                 // We are always overwriting the last tile until it is full and we start on the next tile.
                 nextTile = tile.TileIndex
                 if tile.TileIndex > 0 {
                         tile, err := store.Get(0, tile.TileIndex-1)
                         if err != nil {
                                 return startTime, 0, fmt.Errorf("Failed to read previous tile looking for start conditions: %s", err)
                         }
                         // Start querying from the timestamp of the last commit in the last full tile.
                         startTime = config.NewQuerySince(time.Unix(tile.Commits[len(tile.Commits)-1].CommitTime, 0))
+                        glog.Infof("Picking from range: First: %v", time.Unix(tile.Commits[0].CommitTime, 0))
+                        glog.Infof("Picking from range: Last: %v", time.Unix(tile.Commits[len(tile.Commits)-1].CommitTime, 0))
                 }
         }
         return startTime, nextTile, nil
 }
 
 func tablePrefixFromDatasetName(name config.DatasetName) string {
         switch name {
         case config.DATASET_SKP:
                 return "perf_skps_v2.skpbench"
         case config.DATASET_MICRO:
                 return "perf_bench_v2.microbench"
         }
         return "perf_skps_v2.skpbench"
 }
 
+type CommitSlice []*types.Commit
+
+type CommitSliceSortable []*types.Commit
+
+func (p CommitSliceSortable) Len() int           { return len(p) }
+func (p CommitSliceSortable) Less(i, j int) bool { return p[i].CommitTime < p[j].CommitTime }
+func (p CommitSliceSortable) Swap(i, j int)      { p[i], p[j] = p[j], p[i] }
+
 // gitCommits returns all the Commits that have associated test data, going
 // from now back to 'startTime'.
 func gitCommits(service *bigquery.Service, datasetName config.DatasetName, startTime config.QuerySince) (map[string][]string, []*types.Commit, error) {
         dateMap := make(map[string][]string)
         allCommits := make([]*types.Commit, 0)
 
-        commitHistory, err := db.readCommitsFromDB()
+        commitHashMap := make(map[string]bool)
+
+        commitHistory, err := db.ReadCommitsFromDB()
         if err != nil {
                 return nil, nil, fmt.Errorf("gitCommits: Did not get the commits history from the database: ", err)
         }
 
         queryTemplate := `
 SELECT
   gitHash, FIRST(timestamp) as timestamp, FIRST(gitNumber) as gitNumber
 FROM
   %s%s
 GROUP BY
@@ skipping 27 matching lines @@
                                 if commitHistory[historyIdx].Hash == c.Hash {
                                         *c = *commitHistory[historyIdx]
                                 } else if len(allCommits) > 0 {
                                         // Append to tail_commit
                                         tailCommits := &allCommits[len(allCommits)-1].TailCommits
                                         *tailCommits = append(*tailCommits, commitHistory[historyIdx])
                                         // TODO(jcgregorio) Truncate the commit messages that go into the tail.
                                 }
                         }
                         totalCommits++
-                        allCommits = append(allCommits, c)
+                        // Data may show up for a commit across more than one day, track if a
+                        // commit has already been added, and only add if new.
+                        if _, ok := commitHashMap[c.Hash]; !ok {
+                                commitHashMap[c.Hash] = true
+                                allCommits = append(allCommits, c)
+                        }
                 }
                 dateMap[dates.Date()] = gitHashesForDay
                 glog.Infof("Finding hashes with data, finished day %s, total commits so far %d", dates.Date(), totalCommits)
 
         }
-        // Now reverse allCommits so that it is oldest first.
-        reversedCommits := make([]*types.Commit, len(allCommits), len(allCommits))
-        for i, c := range allCommits {
-                reversedCommits[len(allCommits)-i-1] = c
+        sort.Sort(CommitSliceSortable(allCommits))
+        for _, c := range allCommits {
+                glog.Infof("gitCommits: allcommits: %s %d\n", c.Hash, c.CommitTime)
         }
-        return dateMap, reversedCommits, nil
+        return dateMap, allCommits, nil
 }
 
 // populateParamSet returns the set of all possible values for all the 'params'
 // in Dataset.
 func populateParamSet(tile *types.Tile) {
         // First pull the data out into a map of sets.
         type ChoiceSet map[string]bool
         c := make(map[string]ChoiceSet)
         for _, t := range tile.Traces {
                 for k, v := range t.Params {
@@ skipping 141 matching lines @@
 
 func updateAllTileSets(service *bigquery.Service) {
         glog.Infof("Starting to update all tile sets.")
         for _, datasetName := range config.ALL_DATASET_NAMES {
                 glog.Infof("Starting to update tileset %s.", string(datasetName))
                 begin := time.Now()
 
                 store := filetilestore.NewFileTileStore(*tileDir, string(datasetName))
 
                 startTime, nextTile, err := startConditions(store)
-                glog.Infoln("Found startTime", startTime, "nextTile", nextTile)
+                glog.Infoln("Found startTime", startTime.SqlTsColumn(), "nextTile", nextTile)
                 if err != nil {
                         glog.Errorf("Failed to compute start conditions for dataset %s: %s", string(datasetName), err)
                         continue
                 }
 
                 glog.Infoln("Getting commits")
                 dates, commits, err := gitCommits(service, datasetName, startTime)
                 glog.Infoln("Found commits", commits)
                 if err != nil {
                         glog.Errorf("Failed to read commits for dataset %s: %s", string(datasetName), err)
@@ skipping 46 matching lines @@
         service, err := bigquery.New(client)
         if err != nil {
                 glog.Fatalf("Failed to create a new BigQuery service object: %s", err)
         }
 
         updateAllTileSets(service)
         for _ = range time.Tick(SAMPLE_PERIOD) {
                 updateAllTileSets(service)
         }
 }