Следующая реализация делает мой код параллельным?

Question

У меня было задание в Go для распараллеливания данного цикла кода.Я не уверен, является ли мой код параллельным.

Я попытался просто разделить массив, который у меня был, на две половины и использовал процедуру go на обеих половинах.

package main

import (
    "fmt"
    "math"
)

type Body struct {
    x, y, vx, vy, mass float64
    r, g, b uint
}

func main() {
    var count uint
    var radius float64
    done := make(chan bool)
    fmt.Scan(&count, &radius)
    bodies := make([]Body, count)
    for i := range bodies {
        b := &bodies[i]
        fmt.Scan(&b.x, &b.y, &b.vx, &b.vy, &b.mass, &b.r, &b.g, &b.b)
    }

    updatedBodies := make([]Body, count)
    copy(updatedBodies, bodies)
    mid := len(updatedBodies)/2


    go func(){
    for i := range updatedBodies[mid:] {
        b := &updatedBodies[i+mid]
        for _, ob := range bodies {
            dx, dy := ob.x - b.x, ob.y - b.y
            if dist := math.Sqrt(dx*dx + dy*dy); dist > 1 { // far enough
                accel := 0.0000000000667 * ob.mass / (dist * dist * dist)
                b.vx += accel * dx
                b.vy += accel * dy
            }
        }
        b.x += b.vx
        b.y += b.vy

    }
    done <- true
}()
    go func(){
        for i := range updatedBodies[:mid] {
        b := &updatedBodies[i]
        for _, ob := range bodies {
            dx, dy := ob.x - b.x, ob.y - b.y
            if dist := math.Sqrt(dx*dx + dy*dy); dist > 1 { // far enough
                accel := 0.0000000000667 * ob.mass / (dist * dist * dist)
                b.vx += accel * dx
                b.vy += accel * dy
            }
        }
        b.x += b.vx
        b.y += b.vy

    }
    done <- true
}()

    <- done
    <- done
    fmt.Println(count)
    fmt.Println(radius)
    for _, b := range updatedBodies {
        fmt.Println(b.x, b.y, b.vx, b.vy, b.mass, b.r, b.g, b.b)
    }
}

for i := range updatedBodies {
        b := &updatedBodies[i]
        for _, ob := range bodies {
            dx, dy := ob.x - b.x, ob.y - b.y
            if dist := math.Sqrt(dx*dx + dy*dy); dist > 1 { // far enough
                accel := 0.0000000000667 * ob.mass / (dist * dist * dist)
                b.vx += accel * dx
                b.vy += accel * dy
            }
        }
        b.x += b.vx
        b.y += b.vy

    }

Я спросил профессора о коде, который он сказал, что у меня естьрекурсивно запустить подпрограмму go, чтобы сделать цикл параллельным.

Answer 1

Ваш код выполняется одновременно *, но не обязательно оптимальным образом. По сути, вы разделили рабочую нагрузку на две части и одновременно запускаете обе половины.

[Профессор] сказал, что мне нужно рекурсивно запустить процедуру go, чтобы сделать цикл параллельным.

Это неправда, но я не знаю точных слов, которые сказал ваш профессор, поэтому он, возможно, не лгал вам. Очевидно, он имеет в виду какое-то рекурсивное решение. Я бы не использовал здесь рекурсию, но это был бы один из способов.

Трудно дать ответ, который ищет ваш профессор. Лучший совет - попросить своего профессора объяснить его намерения.

* параллелизм не параллелизм. Пожалуйста, прочитайте / посмотрите это .