並行計算Golang中的工作率計算

Question

我目前正在從事同時進行圖像處理和並行進行圖像處理的工作。 我正在嘗試將工作率作為我的指標的一部分，但是我找不到在線公式或有關該公式的更多信息，

有人有計算工作率所需的方程式嗎？

編輯：

如果這有幫助，這是我的主要功能，其中包含度量標准計算？ 我知道可能有更好的方法可以獲取某些數據等，但是經過反復試驗，我才明白這一點。

runtime.GOMAXPROCS(4)

file, err := os.Open("space.jpg")
if err != nil {
    log.Fatal(err)
}
defer file.Close()

img, err := jpeg.Decode(file)
if err != nil {
    log.Fatal(os.Stderr, "%s: %v\n", "space.jpg", err)
}
for i:= 0; i<10; i++{
TSeqStart := time.Now()
b := img.Bounds()
imgSet := image.NewRGBA(b)
for y := 0; y < b.Max.Y; y++ {
    for x := 0; x < b.Max.X; x++ {
      oldPixel := img.At(x, y)
  r, g, b, _ := oldPixel.RGBA()
  lum := 0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)
  pixel := color.Gray{uint8(lum / 256)}
  imgSet.Set(x, y, pixel)
     }
    }
  TSeq := time.Since(TSeqStart)
  //ns := TSeq.Nanoseconds()

  avgSeq = avgSeq +TSeq
  fmt.Printf("\nTime in ns (Sequential): " , TSeq)
  outFile, err := os.Create("changed.jpg")
  if err != nil {
    log.Fatal(err)
  }
  defer outFile.Close()
  jpeg.Encode(outFile, imgSet, nil)

}
avgSeq = avgSeq/10

fmt.Print("\n\nAverage sequential time for 10 runs: ", avgSeq)
  //parallel version
    file2, err := os.Open("space.jpg")
    if err != nil {
        log.Fatal(err)
    }
    defer file.Close()

    img2, err := jpeg.Decode(file2)
    if err != nil {
        log.Fatal(os.Stderr, "%s: %v\n", "space.jpg", err)
    }

    for j:=1;j<=4;j++{
      runtime.GOMAXPROCS(j)


    for i:= 0; i<10; i++{

    TParStart:= time.Now()
    imgSet2 := imgprocess(img2, runtime.NumCPU(), splitVert(1024), rgbtogrey)
    TPar := time.Since(TParStart)
    //ns2 :=  TPar.Nanoseconds()

    avgPar = avgPar +TPar
    fmt.Print("\nTime in Nanoseconds (Parallel) with GOMAXPROCS set at ",j ,": " , TPar)

    outFile2, err := os.Create("changed2.jpg")
    if err != nil {
      log.Fatal(err)
    }
    defer outFile2.Close()
    jpeg.Encode(outFile2, imgSet2, nil)

      if err != nil {
          log.Fatalf("encoding image: %v", err)
      }
    }
    avgPar = avgPar/10
    fmt.Print("\n\nAverage time for 10 runs in parallel (GOMAXPROCS:",j,"): ", avgPar)
    var j64 time.Duration
    j64 = time.Duration(j)
    totalPar := j64*avgPar
    fmt.Print("\n\nTotal Parallel time: ", totalPar)

      speedup := avgSeq.Seconds()/avgPar.Seconds()

      fmt.Printf("\n\nSpeed up: %f", speedup)

      var jfloat float64
      jfloat = float64(j)
      theoreticalMin := avgSeq.Seconds()/jfloat
      fmt.Print("\n\nTheoretical Minimum: ", theoreticalMin,"ms")

     var tPFloat float64
     tPFloat = float64(totalPar)
      efficiency := avgSeq.Seconds()/tPFloat
      fmt.Print("\n\n Efficiency: ", efficiency,"%")

       overhead := totalPar - avgSeq
       fmt.Print("\n\nOverhead time: ", overhead ,"\n")

Answer 1

首先，我將嘗試解釋這里發生了什么（NumCPU = 4）：

package main

import (
    "image"
    "image/color"
    "image/jpeg"
    "os"
    "testing"
)

func changeImage(img image.Image) {
    b := img.Bounds()
    imgSet := image.NewRGBA(b)
    for y := 0; y < b.Max.Y; y++ {
        for x := 0; x < b.Max.X; x++ {
            oldPixel := img.At(x, y)
            r, g, b, _ := oldPixel.RGBA()
            lum := 0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)
            pixel := color.Gray{uint8(lum / 256)}
            imgSet.Set(x, y, pixel)
        }
    }
}

func BenchmarkParallel(b *testing.B) {
    file, err := os.Open("space.jpg")
    if err != nil {
        b.Fatal(err)
    }
    defer file.Close()
    img, err := jpeg.Decode(file)
    if err != nil {
        b.Fatal(err)
    }

    b.ReportAllocs()
    b.RunParallel(func(pb *testing.PB) {
        for pb.Next() {
            changeImage(img)
        }
    })
}

func BenchmarkSingle(b *testing.B) {
    file, err := os.Open("space.jpg")
    if err != nil {
        b.Fatal(err)
    }
    defer file.Close()
    img, err := jpeg.Decode(file)
    if err != nil {
        b.Fatal(err)
    }

    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        changeImage(img)
    }
}

輸出：

$ go test -bench=. -cpu=1,2,4,6
goos: linux
goarch: amd64
pkg: so/space
BenchmarkParallel        50   22901501 ns/op     2296662 B/op     571021 allocs/op
BenchmarkParallel-2     100   11599582 ns/op     2290637 B/op     571021 allocs/op
BenchmarkParallel-4     200   10631362 ns/op     2287631 B/op     571021 allocs/op
BenchmarkParallel-6     200   10916331 ns/op     2287629 B/op     571021 allocs/op
BenchmarkSingle          50   23645522 ns/op     2284582 B/op     571021 allocs/op
BenchmarkSingle-2        50   23158899 ns/op     2284584 B/op     571021 allocs/op
BenchmarkSingle-4        50   31069104 ns/op     2284589 B/op     571021 allocs/op
BenchmarkSingle-6        50   28026326 ns/op     2284586 B/op     571021 allocs/op
PASS
ok      so/space    14.047s

---

附錄：

接下來，閱讀相關文檔。

Go圖片包

包裝圖

包裝顏色

修復錯誤並針對優化版本進行改進。 將優化版本與我們之前建立的基准進行比較。

package main

import (
    "image"
    "image/color"
    "image/jpeg"
    "os"
    "testing"
)

func changeImageOpt(img image.Image) *image.RGBA {
    b := img.Bounds()
    imgSet := image.NewRGBA(b)
    for y := b.Min.Y; y < b.Max.Y; y++ {
        for x := b.Min.X; x < b.Max.X; x++ {
            r, g, b, _ := img.At(x, y).RGBA()
            lum := 0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)
            r, g, b, a := color.Gray{uint8(lum / 256)}.RGBA()
            rgba := color.RGBA{R: uint8(r), G: uint8(g), B: uint8(b), A: uint8(a)}
            imgSet.SetRGBA(x, y, rgba)
        }
    }
    return imgSet
}

func BenchmarkSingleOpt(b *testing.B) {
    file, err := os.Open("space.jpg")
    if err != nil {
        b.Fatal(err)
    }
    defer file.Close()
    img, err := jpeg.Decode(file)
    if err != nil {
        b.Fatal(err)
    }

    b.ReportAllocs()
    b.ResetTimer()
    for i := 0; i < b.N; i++ {
        changeImageOpt(img)
    }
}

輸出：

$ go test -bench=Single -cpu=2
goos: linux
goarch: amd64
pkg: so/space
BenchmarkSingle-2        20   84970866 ns/op     2284584 B/op     571021 allocs/op
BenchmarkSingleOpt-2     30   48353165 ns/op     1371010 B/op     190342 allocs/op
PASS
ok      so/space    4.648s

按照文檔中的說明，我們大大減少了CPU時間和內存分配。

並行基准測試有相應的改進（NumCPU = 4）。

$ go test -bench=Parallel -cpu=1,2,3,4,6
goos: linux
goarch: amd64
pkg: so/space
BenchmarkParallel        20   87135554 ns/op     2314774 B/op     571021 allocs/op
BenchmarkParallel-2      30   46567417 ns/op     2304732 B/op     571021 allocs/op
BenchmarkParallel-3      30   43262344 ns/op     2304736 B/op     571021 allocs/op
BenchmarkParallel-4      30   42593397 ns/op     2304763 B/op     571021 allocs/op
BenchmarkParallel-6      30   40803415 ns/op     2304804 B/op     571021 allocs/op
BenchmarkParallelOpt     30   47932887 ns/op     1391139 B/op     190342 allocs/op
BenchmarkParallelOpt-2   50   25216902 ns/op     1383094 B/op     190342 allocs/op
BenchmarkParallelOpt-3   50   23723356 ns/op     1383099 B/op     190342 allocs/op
BenchmarkParallelOpt-4   50   22400713 ns/op     1383101 B/op     190342 allocs/op
BenchmarkParallelOpt-6   50   22250405 ns/op     1383100 B/op     190342 allocs/op
PASS
ok      so/space    19.662s