gemma: pkg/controllers/stretches.go comparison

comparison pkg/controllers/stretches.go @ 3452:ae6c09fbc590

fairway depth/availability: bring unified CVS to streches and sections, too.

author	Sascha L. Teichmann <sascha.teichmann@intevation.de>
date	Fri, 24 May 2019 13:09:08 +0200
parents	d7ddb21f7017
children	7265adcc5baa

comparison

equal deleted inserted replaced

-:8634d2bd0aac
+:ae6c09fbc590
 		measurements availMeasurements
 		ldc          []float64
 		breaks       []float64
 		access       func(*availMeasurement) float64
 	}
+	availResult struct {
+		label       string
+		from, to    time.Time
+		ldc, breaks []time.Duration
+	}
+	availCalculation struct {
+		result      *availResult
+		ldc, breaks []time.Duration
+	}
+	availJob struct {
+		result *availResult
+		bn     *fullStretchBottleneck
+	}
 )
+func (r *availResult) add(c availCalculation) {
+	for i, v := range c.ldc {
+		r.ldc[i] += v
+	}
+	for i, v := range c.breaks {
+		r.breaks[i] += v
+	}
+}
 func (bns stretchBottlenecks) contains(limiting string) bool {
 	for i := range bns {
 		if bns[i].limiting == limiting {
 			return true
 func stretchAvailableFairwayDepth(rw http.ResponseWriter, req *http.Request) {
 	vars := mux.Vars(req)
 	stretch := vars["kind"] == "stretch"
 	name := vars["name"]
 	mode := intervalMode(req.FormValue("mode"))
 	depthbreaks, widthbreaks := afdRefs, afdRefs
 	from, ok := parseFormTime(rw, req, "from", time.Now().AddDate(-1, 0, 0))
 			http.StatusInternalServerError,
 		)
 		return
 	}
-	type (
-		result struct {
-			label       string
-			from, to    time.Time
-			ldc, breaks []time.Duration
-		}
-		calculation struct {
-			result      *result
-			ldc, breaks []time.Duration
-		}
-		job struct {
-			result *result
-			bn     *fullStretchBottleneck
-		}
-	)
 	n := runtime.NumCPU() / 2
 	if n == 0 {
 		n = 1
 	}
-	jobCh := make(chan job)
+	jobCh := make(chan availJob)
-	calcCh := make(chan calculation, n)
+	calcCh := make(chan availCalculation, n)
 	done := make(chan struct{})
 	var wg sync.WaitGroup
 	go func() {
 		defer close(done)
 		for calc := range calcCh {
-			ldc := calc.result.ldc
+			calc.result.add(calc)
-			for i, v := range calc.ldc {
-				ldc[i] += v
-			}
-			breaks := calc.result.breaks
-			for i, v := range calc.breaks {
-				breaks[i] += v
-			}
 		}
 	}()
 	for i := 0; i < n; i++ {
 		wg.Add(1)
 				breaks := bn.measurements.classify(
 					res.from, res.to,
 					bn.breaks,
 					bn.access,
 				)
-				calcCh <- calculation{
+				calcCh <- availCalculation{
 					result: res,
 					breaks: breaks,
 					ldc:    ldc,
 				}
 			}
 		}()
 	}
-	var results []*result
+	var results []*availResult
 	interval := intervals[mode](from, to)
 	var breaks []float64
 		breaks = widthbreaks
 	}
 	for pfrom, pto, label := interval(); label != ""; pfrom, pto, label = interval() {
-		res := &result{
+		res := &availResult{
 			label:  label,
 			from:   pfrom,
 			to:     pto,
 			ldc:    make([]time.Duration, 2),
 			breaks: make([]time.Duration, len(breaks)+1),
 		}
 		results = append(results, res)
 		for _, bn := range loaded {
-			jobCh <- job{bn: bn, result: res}
+			jobCh <- availJob{bn: bn, result: res}
 		}
 	}
 	close(jobCh)
 	wg.Wait()
 	close(calcCh)
 	<-done
 	rw.Header().Add("Content-Type", "text/csv")
 	out := csv.NewWriter(rw)
-	// label, classes, lnwl
+	// label, lnwl, classes
-	record := make([]string, 1+1+len(breaks)+1)
+	record := make([]string, 1+2+len(breaks)+1)
-	record[0] = "#label"
+	record[0] = "# time"
-	record[1] = "# >= LDC [h]"
+	record[1] = "# < LDC [h]"
+	record[2] = "# >= LDC [h]"
 	for i, v := range breaks {
 		if useDepth && useWidth {
 			if i == 0 {
-				record[2] = "# < break_1 [h]"
+				record[3] = "# < break_1 [h]"
 			}
-			record[i+3] = fmt.Sprintf("# >= break_%d", i+1)
+			record[i+4] = fmt.Sprintf("# >= break_%d", i+1)
 		} else {
 			if i == 0 {
-				record[2] = fmt.Sprintf("# < %.2f [h]", v)
+				record[3] = fmt.Sprintf("# < %.2f [h]", v)
 			}
-			record[i+3] = fmt.Sprintf("# >= %.2f [h]", v)
+			record[i+4] = fmt.Sprintf("# >= %.2f [h]", v)
 		}
 	}
 	if err := out.Write(record); err != nil {
 		// Too late for HTTP status message.
 	// Normalize to look like as we have only one bottleneck.
 	scale := 1 / float64(len(loaded))
 	for _, r := range results {
 		record[0] = r.label
-		record[1] = fmt.Sprintf("%.3f", r.ldc[1].Hours()*scale)
+		for i, v := range r.ldc {
+			record[1+i] = fmt.Sprintf("%.3f", v.Hours()*scale)
+		}
 		for i, d := range r.breaks {
-			record[2+i] = fmt.Sprintf("%.3f", d.Hours()*scale)
+			record[3+i] = fmt.Sprintf("%.3f", d.Hours()*scale)
 		}
 		if err := out.Write(record); err != nil {
 			// Too late for HTTP status message.
 			log.Printf("error: %v\n", err)
 func stretchAvailabilty(rw http.ResponseWriter, req *http.Request) {
 	vars := mux.Vars(req)
 	stretch := vars["kind"] == "stretch"
 	name := vars["name"]
+	mode := intervalMode(req.FormValue("mode"))
 	if name == "" {
 		http.Error(
 			rw,
 			fmt.Sprintf("Missing %s name", vars["kind"]),
 			http.StatusInternalServerError,
 		)
 		return
 	}
-	type calculation struct {
-		ldc, afd []time.Duration
-	}
 	n := runtime.NumCPU() / 2
 	if n == 0 {
 		n = 1
 	}
-	var breaks []float64
+	jobCh := make(chan availJob)
-	if useDepth {
+	calcCh := make(chan availCalculation, n)
-		breaks = depthbreaks
-	} else {
-		breaks = widthbreaks
-	}
-	jobCh := make(chan *fullStretchBottleneck)
-	calcCh := make(chan calculation, n)
 	done := make(chan struct{})
-	ldc := make([]time.Duration, 2)
-	afd := make([]time.Duration, len(breaks)+1)
 	var wg sync.WaitGroup
 	go func() {
 		defer close(done)
 		for calc := range calcCh {
-			for i, v := range calc.ldc {
+			calc.result.add(calc)
-				ldc[i] += v
-			}
-			for i, v := range calc.afd {
-				afd[i] += v
-			}
 		}
 	}()
 	for i := 0; i < n; i++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
-			for bn := range jobCh {
+			for job := range jobCh {
+				bn := job.bn
+				res := job.result
 				ldc := bn.measurements.classify(
 					from, to,
 					bn.ldc,
 					(*availMeasurement).getValue,
 				)
-				afd := bn.measurements.classify(
+				breaks := bn.measurements.classify(
 					from, to,
 					bn.breaks,
 					bn.access,
 				)
-				calcCh <- calculation{ldc: ldc, afd: afd}
+				calcCh <- availCalculation{
+					result: res,
+					breaks: breaks,
+					ldc:    ldc,
+				}
 			}
 		}()
 	}
-	for _, bn := range loaded {
+	var results []*availResult
-		jobCh <- bn
+	interval := intervals[mode](from, to)
+	var breaks []float64
+	if useDepth {
+		breaks = depthbreaks
+	} else {
+		breaks = widthbreaks
+	}
+	for pfrom, pto, label := interval(); label != ""; pfrom, pto, label = interval() {
+		res := &availResult{
+			label:  label,
+			from:   pfrom,
+			to:     pto,
+			ldc:    make([]time.Duration, 2),
+			breaks: make([]time.Duration, len(breaks)+1),
+		}
+		results = append(results, res)
+		for _, bn := range loaded {
+			jobCh <- availJob{bn: bn, result: res}
+		}
 	}
 	close(jobCh)
 	wg.Wait()
 	close(calcCh)
 	<-done
-	duration := to.Sub(from) * time.Duration(len(loaded))
+	rw.Header().Add("Content-Type", "text/csv")
-	lnwlPercents := durationsToPercentage(duration, ldc)
+	out := csv.NewWriter(rw)
-	afdPercents := durationsToPercentage(duration, afd)
+	// label, lnwl, classes
-	_ = lnwlPercents
+	record := make([]string, 1+2+len(breaks)+1)
-	_ = afdPercents
+	record[0] = "# time"
+	record[1] = "# < LDC [%%]"
-	/* // TODO: Rewrite this
+	record[2] = "# >= LDC [%%]"
+	for i, v := range breaks {
-	type ldcOutput struct {
+		if useDepth && useWidth {
-		Value float64 `json:"value"`
+			if i == 0 {
-		Below float64 `json:"below"`
+				record[3] = "# < break_1 [%%]"
-		Above float64 `json:"above"`
+			}
-	}
+			record[i+4] = fmt.Sprintf("# >= break_%d [%%]", i+1)
+		} else {
-	type intervalOutput struct {
+			if i == 0 {
-		From    *float64 `json:"from,omitempty"`
+				record[3] = fmt.Sprintf("# < %.3f [%%]", v)
-		To      *float64 `json:"to,omitempty"`
+			}
-		Percent float64  `json:"percent"`
+			record[i+4] = fmt.Sprintf("# >= %.3f [%%]", v)
-	}
+		}
+	}
-	type output struct {
-		LDC []intervalOutput `json:"ldc"`
+	if err := out.Write(record); err != nil {
-		AFD []intervalOutput `json:"afd"`
+		// Too late for HTTP status message.
-	}
+		log.Printf("error: %v\n", err)
+		return
-	out := output{
+	}
-		LDC: []intervalOutput{
-			{To: new(float64), Percent: lnwlPercents[0]},
+	for _, r := range results {
-			{From: new(float64), Percent: lnwlPercents[1]},
+		duration := r.to.Sub(r.from) * time.Duration(len(loaded))
-		},
-	}
+		ldcPercents := durationsToPercentage(duration, r.ldc)
+		breaksPercents := durationsToPercentage(duration, r.breaks)
-	// XXX: In mixed mode the breaks are not correct!
+		record[0] = r.label
-	for i, percent := range afdPercents {
-		var from, to *float64
+		for i, v := range ldcPercents {
-		switch {
+			record[2+i] = fmt.Sprintf("%.3f", v)
-		case i == 0:
+		}
-			to = &breaks[i]
-		case i == len(afdPercents)-1:
+		for i, v := range breaksPercents {
-			from = &breaks[len(breaks)-1]
+			record[3+i] = fmt.Sprintf("%.3f", v)
-		default:
+		}
-			from = &breaks[i-1]
-			to = &breaks[i]
+		if err := out.Write(record); err != nil {
-		}
+			// Too late for HTTP status message.
-		out.AFD = append(out.AFD, intervalOutput{
+			log.Printf("error: %v\n", err)
-			From:    from,
+			return
-			To:      to,
+		}
-			Percent: percent,
+	}
-		})
-	}
+	out.Flush()
+	if err := out.Error(); err != nil {
-	jr = JSONResult{Result: &out}
+		// Too late for HTTP status message.
-	return
+		log.Printf("error: %v\n", err)
-	*/
+	}
 }

Mercurial > gemma

comparison pkg/controllers/stretches.go @ 3452:ae6c09fbc590