我有一個(gè)項(xiàng)目，需要在CPU的多個(gè)內(nèi)核上運(yùn)行它以獲得更快的速度。我在福特蘭中使用了omplib，但我不熟悉戈朗并行性。我嘗試了戈魯丁，但那是錯(cuò)的，弄得一團(tuán)糟，我得到了錯(cuò)誤的結(jié)果。這是我的代碼：package mainimport ( "bufio" "fmt" "log" "math" "math/rand" "os" "time")const ( n_particles int = 2048 n_steps int = 1000000 dt float64 = 1.0 v0 float64 = 0.50 radius float64 = 1.0 f_intensity float64 = 1.8 scale float64 = 32.0 alpha float64 = 1.0 / 36.0)var ( x [n_particles + 1]float64 y [n_particles + 1]float64 angles [n_particles + 1]float64 vx [n_particles + 1]float64 vy [n_particles + 1]float64 order [n_steps + 1]float64)func main() { /////randomizer vstart := time.Now() rsource := rand.NewSource(time.Now().UnixNano()) randomizer := rand.New(rsource) for i := 0; i <= n_particles; i++ { x[i] = (randomizer.Float64()) * scale y[i] = (randomizer.Float64()) * scale angles[i] = (randomizer.Float64()) * math.Pi * 2 sin, cos := math.Sincos(angles[i]) vx[i] = v0 * cos vy[i] = v0 * sin } //////main loop for i := 0; i <= n_steps; i++ { start := time.Now() for j := 0; j <= n_particles; j++ { x[j] = x[j] + (vx[j] * dt) //x[j] = math.Mod(x[j], scale) if x[j] < 0.0 { x[j] = x[j] + scale } if x[j] >= scale { x[j] = x[j] - scale } y[j] = y[j] + (vy[j] * dt) //y[j] = math.Mod(x[j], scale) if y[j] < 0.0 { y[j] = y[j] + scale } if y[j] >= scale { y[j] = y[j] - scale } }
1 回答
藍(lán)山帝景
TA貢獻(xiàn)1843條經(jīng)驗(yàn) 獲得超7個(gè)贊
以下是兩種嘗試方法：https://play.golang.org/p/O1uB2zzJEC5
package main
import (
"fmt"
"sync"
)
func main() {
waitGroupApproach()
channelApproach()
}
func waitGroupApproach() {
fmt.Println("waitGroupApproach")
var waitgroup sync.WaitGroup
result_table := make([]int, 6, 6)
for j := 0; j <= 5; j++ {
waitgroup.Add(1)
go func(index int) {
fmt.Println(index) // try putting here `j` instea of `index`
result_table[index] = index*2
waitgroup.Done()
}(j) // you have to put any for-loop variables into closure
// because otherwsie all routines inside will likely get the last j == n_particles + 1
// as they will likely run after the loop has finished
}
fmt.Println("waiting")
waitgroup.Wait()
// process results further
fmt.Println("finished")
fmt.Println(result_table)
}
func channelApproach() {
fmt.Println("\nchannelApproach")
type intpos struct {
x, y, index int
}
results := make(chan intpos)
// initialize routines
for j := 0; j <= 5; j++ {
go func(index int) {
// do processing
results <- intpos{index*2, index*3, index}
}(j)
}
fmt.Println("Waiting..")
// collect results, iterate the same number of times
result_table := make([]int, 6)
for j := 0; j <= 5; j++ {
r := <- results
// watch out order, migth not be the same as in invocation,
// so that's why I store j in results as well
fmt.Println(r.index, r.x, r.y)
result_table[r.index] = r.x
}
fmt.Println("Finished..")
fmt.Println(result_table)
}
我更喜歡通道方法，因?yàn)樗鼘?duì)我來(lái)說(shuō)更像是慣用語(yǔ)，它允許更容易處理恐慌，錯(cuò)誤條件等。
- 1 回答
- 0 關(guān)注
- 85 瀏覽
添加回答
舉報(bào)
0/150
提交
取消