Added HTTP endpoints for Correctness counts

golden/go/analysis/analysis.go

 package analysis
 
 import (
         "sync"
         "time"
 
         "github.com/golang/glog"
         "github.com/rcrowley/go-metrics"
 
         "skia.googlesource.com/buildbot.git/go/util"
         "skia.googlesource.com/buildbot.git/golden/go/diff"
         "skia.googlesource.com/buildbot.git/golden/go/expstorage"
         "skia.googlesource.com/buildbot.git/golden/go/types"
         ptypes "skia.googlesource.com/buildbot.git/perf/go/types"
 )
 
 // Stores a Trace with labels and digests in memory. CommitIds, Digests and
 // Labels are of the same length, identical indices refer to the same digest.
 type LabeledTrace struct {
-        Params    map[string]string `json:"params"`
-        CommitIds []int             `json:"commitIds"`
-        Digests   []string          `json:"digests"`
-        Labels    []types.Label     `json:"labels`
+        Params    map[string]string
+        CommitIds []int
+        Digests   []string
+        Labels    []types.Label
 }
 
 func NewLabeledTrace(params map[string]string, capacity int) *LabeledTrace {
         return &LabeledTrace{
                 Params:    params,
                 CommitIds: make([]int, 0, capacity),
                 Digests:   make([]string, 0, capacity),
                 Labels:    make([]types.Label, 0, capacity),
         }
 }
 
 // Add the given tripples of commitIds, digests and labels to this LabeledTrace.
 func (lt *LabeledTrace) addLabeledDigests(commitIds []int, digests []string, labels []types.Label) {
         lt.CommitIds = append(lt.CommitIds, commitIds...)
         lt.Digests = append(lt.Digests, digests...)
         lt.Labels = append(lt.Labels, labels...)
 }
 
 // Aggregates the Traces in tile and provides the commits that the
 // CommitIds in LabeledTrace refer to.
+// LabeledTile and LabeledTrace are used to store the cannonical information
+// extracted from the tiles. The (redundant) output data is derived from these.
 type LabeledTile struct {
-        Commits []*ptypes.Commit `json:"commits"`
+        Commits []*ptypes.Commit
 
         // Traces are indexed by the primary key (test name). This is somewhat
         // redundant, but this also output format.
-        Traces map[string][]*LabeledTrace `json:"traces"`
+        Traces map[string][]*LabeledTrace
 }
 
 func NewLabeledTile() *LabeledTile {
         return &LabeledTile{
                 Commits: []*ptypes.Commit{},
                 Traces:  map[string][]*LabeledTrace{},
         }
 }
 
 // Utility function that returns the testName and a labeled trace for the given
@@ skipping 14 matching lines @@
                 }
         }
 
         // If we cannot find the trace in our set of tests we are adding a new
         // labeled trace.
         newLT := NewLabeledTrace(params, trace.Len())
         t.Traces[pKey] = append(t.Traces[pKey], newLT)
         return pKey, newLT
 }
 
+// GUITileCounts is an output type for the aggregated label counts.
+// The tupples in Counts store: untriaged, positive, negatives
+type GUITileCounts struct {
+        Commits []*ptypes.Commit      `json:"commits"`
+        Counts  map[string][][3]int64 `json:"counts"`

[jcgregorio, 2014/10/17 18:07:52]

[3]int64 is a little ambiguous as far as figuring out which is untriaged vs pos
vs neg. Why not use a simple struct:

struct { 
  Unk int64
  Pos int64
  Neg int64
}

[stephana, 2014/10/17 20:01:45]

Done.

+}
+
+// GUITestCounts is an output type for a single test that contains the
+// aggregated counts over all traces and invidual trace labels.
+type GUITestCounts struct {
+        Commits    []*ptypes.Commit   `json:"commits"`
+        Aggregated [][3]int64         `json:"aggregated"`
+        Traces     []*GUILabeledTrace `json:"traces"`
+}
+
+// GUILabeledTrace is an output type for the labels of a trace.
+type GUILabeledTrace struct {
+        Params map[string]string `json:"params"`
+
+        // Contains (commitId, lable) pairs.
+        Labels [][2]uint64 `json:"labels"`

[jcgregorio, 2014/10/17 18:07:52]

Why not map[int64]int64 or []struct{ ID int64, Label int64}?

[stephana, 2014/10/17 20:01:45]

Done.

+}
+
 // Analyzer continuously manages the tasks, like pollint for new traces
 // on disk, etc.
 type Analyzer struct {
         expStore  expstorage.ExpectationsStore
         diffStore diff.DiffStore
         tileStore ptypes.TileStore
 
+        // Canonical data structure to hold our information about commits, digests
+        // and labels.
         currentTile *LabeledTile
 
-        // Lock to protect the expectations and the current labeled tile.
+        // Output data structures that are derived from currentTile.
+        currentTileCounts *GUITileCounts
+        currentTestCounts map[string]*GUITestCounts
+
+        // Lock to protect the expectations and current* variables.
         mutex sync.Mutex
 }
 
 func NewAnalyzer(expStore expstorage.ExpectationsStore, tileStore ptypes.TileStore, diffStore diff.DiffStore, timeBetweenPolls time.Duration) *Analyzer {
         result := &Analyzer{
                 expStore:  expStore,
                 diffStore: diffStore,
                 tileStore: tileStore,
 
                 currentTile: NewLabeledTile(),
         }
 
         go result.loop(timeBetweenPolls)
         return result
 }
 
 // Returns an entire Tile which is a collection of 'traces' over a series of
 // of commits. Each trace contains the digests and their labels based on
 // out knowledge base about digests (expectations).
-func (a *Analyzer) GetLabeledTile() *LabeledTile {
+func (a *Analyzer) GetTileCounts() (*GUITileCounts, error) {
         a.mutex.Lock()
         defer a.mutex.Unlock()
 
-        return a.currentTile
+        return a.currentTileCounts, nil
 }
 
-func (a *Analyzer) GetLabeledTraces(testName string) []*LabeledTrace {
+func (a *Analyzer) GetTestCounts(testName string) (*GUITestCounts, error) {
         a.mutex.Lock()
         defer a.mutex.Unlock()
 
-        return a.currentTile.Traces[testName]
+        return a.currentTestCounts[testName], nil
 }
 
 func (a *Analyzer) SetDigestLabels(labeledTestDigests map[string]types.TestClassification, userId string) (map[string][]*LabeledTrace, error) {
         a.mutex.Lock()
         defer a.mutex.Unlock()
 
         expectations, err := a.expStore.Get(true)
         if err != nil {
                 return nil, err
         }
@@ skipping 18 matching lines @@
         for {
                 glog.Info("Reading tiles ... ")
 
                 // Load the tile and process it.
                 tile, err := a.tileStore.Get(0, -1)
                 if err != nil {
                         glog.Errorf("Error reading tile store: %s\n", err.Error())
                         errorTileLoadingCounter.Inc(1)
                 } else {
                         newLabeledTile := a.processTile(tile)
+                        newTileCounts, newTestCounts := a.getOutputCounts(newLabeledTile)
+
                         a.mutex.Lock()
                         a.currentTile = newLabeledTile
+                        a.currentTileCounts = newTileCounts
+                        a.currentTestCounts = newTestCounts
                         a.mutex.Unlock()
                 }
                 runsCounter.Inc(1)
 
                 // Sleep for a while until the next poll.
                 time.Sleep(timeBetweenPolls)
         }
 }
 
 // Process a tile segment and add it to the currentTile.
@@ skipping 66 matching lines @@
         for idx, digest := range digests {
                 if test, ok := expectations.Tests[testName]; ok {
                         if foundLabel, ok := test[digest]; ok {
                                 targetLabels[idx] = foundLabel
                         }
                 }
         }
 
         return nil
 }
+
+// Derive the output counts from the given labeled tile.
+func (a *Analyzer) getOutputCounts(labeledTile *LabeledTile) (*GUITileCounts, map[string]*GUITestCounts) {
+        // Stores the aggregated counts of a tile for each test.
+        tileCountsMap := make(map[string][][3]int64, len(labeledTile.Traces))
+
+        // Stores the aggregated counts for each test and individual trace information.
+        testCountsMap := make(map[string]*GUITestCounts, len(labeledTile.Traces))
+
+        for testName, testTraces := range labeledTile.Traces {
+                acc := make([][3]int64, len(labeledTile.Commits))
+                tempTraces := make([]*GUILabeledTrace, 0, len(testTraces))
+
+                for _, oneTrace := range testTraces {
+                        tempTrace := &GUILabeledTrace{
+                                Params: oneTrace.Params,
+                                Labels: make([][2]uint64, len(oneTrace.CommitIds)),
+                        }
+
+                        for i, ci := range oneTrace.CommitIds {
+                                // Increment the tuple element based on Label constant values.
+                                acc[ci][oneTrace.Labels[i]]++
+                                tempTrace.Labels[i][0] = uint64(ci)
+                                tempTrace.Labels[i][1] = uint64(oneTrace.Labels[i])
+                        }
+                }
+
+                tileCountsMap[testName] = acc
+                testCountsMap[testName] = &GUITestCounts{
+                        Commits:    labeledTile.Commits,
+                        Aggregated: acc,
+                        Traces:     tempTraces,
+                }
+        }
+
+        tileCounts := &GUITileCounts{
+                Commits: labeledTile.Commits,
+                Counts:  tileCountsMap,
+        }
+
+        return tileCounts, testCountsMap
+}