Google Go parallel Merge Sort - sorting

Question

I successfully implemented Merge Sort Parallely on Google Go, but the problem is that sometimes parallel solution takes more time to sort than normal.
Here is my code:
package main
import "fmt"
import "math/rand"
import "time"
import "sync"
const (
n = 1000000;
)
var nProcess = 1;
func generateData() [n]int {
var data [n]int;
rand.Seed(time.Now().UnixNano());
for i := 0; i < n; i++ {
data[i] = rand.Intn(100);
}
return data;
}
func merge(a []int, b []int) []int {
i, j, k := 0, 0, 0
var out = make([]int, len(a)+len(b));
for ; i < len(a) && j < len(b); k++ {
if a[i] < b[j] {
out[k] = a[i]
i++
} else {
out[k] = b[j]
j++
}
}
if i < len(a) {
copy(out[k:], a[i:])
} else {
copy(out[k:], b[j:])
}
return out;
}
func mergeSort(data []int, level int) []int {
var halfSize = len(data)/2;
var a = make([]int, halfSize);
var b = make([]int, halfSize);
var low = 0;
var mid = (0 + len(data)-1) / 2;
var high = len(data)-1;
a = data[low:mid+1];
b = data[mid+1:high+1];
level = level + 1;
var wg sync.WaitGroup
if(len(data) > 1) {
if( level < nProcess ) {
wg.Add(2);
go func() { go func() { b = mergeSort(b[:], level); wg.Done(); }(); a = mergeSort(a[:], level); wg.Done(); }()
wg.Wait();
}else {
a = mergeSort(a[:], level);
b = mergeSort(b[:], level);
}
}
var out = merge(a[:], b[:]);
return out;
}
func main() {
var data = generateData();
nProcess = 1;
start := time.Now();
var data2 = mergeSort(data[:], 1);
duration := time.Since(start);
fmt.Println("Processes: ", nProcess);
fmt.Println("Data: ", len(data2));
fmt.Println("Duration: ", duration);
nProcess = 4;
start = time.Now();
data2 = mergeSort(data[:], 1);
duration = time.Since(start);
fmt.Println("Processes: ", nProcess);
fmt.Println("Data: ", len(data2));
fmt.Println("Duration: ", duration);
}
I need to compare results with how many processes do the job. I decided to declare a nProcess. For example if it is = 1 then no parallel code will be executed as you can see from if statement. Everything will be calculated in normal flow. The bigger number is, the deeper in merge sort portions will be executed parallely. The problem is that results are not that impressively different as I think it should be. Maybe you can spot where I did a mistake? Is merging is really executed parallely?