concurrency - Goroutine execution time with different input data -

I am experimenting with goroutine for parallel to some calculation. However, the performance time of the goroutine confuses me. My experiment setup is simple

  runtime. GMXSPRCS (3) data: = 1000000000 data 21: = make ([] float64, ditlen) data 22: = make ([] float64, ditlen) data 23: = make ([] float64, datalen) t: = time .Now () res: = make (chan interface {}, dlen) go func () {i: = 0; I & lt; Datalen; I ++ {data22 [i] = math.Sqrt (13)} res & lt; - true} () go func () {i: = 0; I & lt; Datalen; I ++ {data22 [i] = math.Sqrt (13)} res & lt; - true} () go func () {i: = 0; I & lt; Datalen; I ++ {data22 [i] = math.Sqrt (13)} res & lt; - true} () for i: = 0; I & lt; 3; I ++ {& lt; -re} fmt.Printf ("moved% v to run parallel to loop. \ N", time. (T))  

Note that I only loaded 3 Data in goroutines, execution time for this program is

  took 7.436060182s to run parallel to the loop.  

However, if I handle different data for each grotin, then the following are as follows:

  runtime. GOMAXPROCS (3) datalen: = 1000000000 data21: = make ([] Float64, datalen) Data 22: = create ([] float64, datalen) Data 23: = create ([] float64, datalen) t: = time.Now ( ) Res: = make (chan interface {}, dlen) go func () {I: = 0; I & lt; Datalen; I ++ {data21 [i] = math.Sqrt (13)} res & lt; - true} () go func () {i: = 0; I & lt; Datalen; I ++ {data22 [i] = math.Sqrt (13)} res & lt; - true} () go func () {i: = 0; I & lt; Datalen; I ++ {data23 [i] = math.Sqrt (13)} res & lt; - true} () i: for = 0; I & lt; 3; I ++ {& lt; -re} fmt.Printf ("% v has been taken to run parallel to loop. \ N", time. (T))  

The execution time for this is the comparison of the previous In approximately 3 times more and almost equals / more, then gradual execution takes the parallel 20.744438468 for the loop

  without looping.  

I think maybe I'm using Gorontan wrongly. So what should be the right way to use different gorants to handle data of different pieces;

The program is not computing any enough, the obstacles are going to accelerate, Can be written in With the setting as an example, we are talking about things which are written in 22 GB which is not negligible.

Given the differences in the time of running two instances, one probability is that it is not actually written as much as RAM, assuming that memory writing is cached by the CPU, The execution probably looks like this:

1. The first gorgetin data is written in the cache line which is the data22 array.
2. The second goroutin writes in the cache line representing the data in the same place. The CPU runs the first grotinine notice that the writing invalidates its cached writing, so its changes are thrown away.
3. The third presents the goroutin data in the cash line representing the same place. The CPU is running another garantine notice that by writing it invalidates its cached writing, its changes are thrown away.
4. The cache line has been ejected in the third CPU and the changes are written on RAM.

This process continues because goroutines progress through the data22 array as the RAM is interrupted and we write more than one third of the data in this scenario, Not surprisingly, it runs about 3 times faster in the second case.