2011-04-21 10:09:25 -06:00
|
|
|
// Copyright 2011 The Go Authors. All rights reserved.
|
|
|
|
// Use of this source code is governed by a BSD-style
|
|
|
|
// license that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
package runtime_test
|
|
|
|
|
|
|
|
import (
|
2013-02-28 15:41:45 -07:00
|
|
|
"math"
|
2011-04-21 10:09:25 -06:00
|
|
|
"runtime"
|
2011-07-12 10:24:32 -06:00
|
|
|
"sync/atomic"
|
2013-06-15 06:06:28 -06:00
|
|
|
"syscall"
|
2011-04-21 10:09:25 -06:00
|
|
|
"testing"
|
2013-02-14 13:02:12 -07:00
|
|
|
"time"
|
2011-04-21 10:09:25 -06:00
|
|
|
)
|
|
|
|
|
2011-04-22 13:22:11 -06:00
|
|
|
var stop = make(chan bool, 1)
|
|
|
|
|
2011-04-21 10:09:25 -06:00
|
|
|
func perpetuumMobile() {
|
2011-04-22 13:22:11 -06:00
|
|
|
select {
|
|
|
|
case <-stop:
|
|
|
|
default:
|
|
|
|
go perpetuumMobile()
|
|
|
|
}
|
2011-04-21 10:09:25 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestStopTheWorldDeadlock(t *testing.T) {
|
2011-04-23 08:03:51 -06:00
|
|
|
if testing.Short() {
|
2013-01-23 23:32:10 -07:00
|
|
|
t.Skip("skipping during short test")
|
2011-04-23 08:03:51 -06:00
|
|
|
}
|
2011-05-31 08:38:51 -06:00
|
|
|
maxprocs := runtime.GOMAXPROCS(3)
|
|
|
|
compl := make(chan bool, 2)
|
2011-04-21 10:09:25 -06:00
|
|
|
go func() {
|
|
|
|
for i := 0; i != 1000; i += 1 {
|
|
|
|
runtime.GC()
|
|
|
|
}
|
2011-05-31 08:38:51 -06:00
|
|
|
compl <- true
|
2011-04-21 10:09:25 -06:00
|
|
|
}()
|
|
|
|
go func() {
|
|
|
|
for i := 0; i != 1000; i += 1 {
|
|
|
|
runtime.GOMAXPROCS(3)
|
|
|
|
}
|
2011-05-31 08:38:51 -06:00
|
|
|
compl <- true
|
2011-04-21 10:09:25 -06:00
|
|
|
}()
|
|
|
|
go perpetuumMobile()
|
|
|
|
<-compl
|
2011-05-31 08:38:51 -06:00
|
|
|
<-compl
|
2011-04-22 13:22:11 -06:00
|
|
|
stop <- true
|
2011-05-31 08:38:51 -06:00
|
|
|
runtime.GOMAXPROCS(maxprocs)
|
2011-04-21 10:09:25 -06:00
|
|
|
}
|
2011-07-12 10:24:32 -06:00
|
|
|
|
2013-02-20 01:13:04 -07:00
|
|
|
func TestYieldProgress(t *testing.T) {
|
|
|
|
testYieldProgress(t, false)
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestYieldLockedProgress(t *testing.T) {
|
|
|
|
testYieldProgress(t, true)
|
|
|
|
}
|
|
|
|
|
|
|
|
func testYieldProgress(t *testing.T, locked bool) {
|
|
|
|
c := make(chan bool)
|
|
|
|
cack := make(chan bool)
|
|
|
|
go func() {
|
|
|
|
if locked {
|
|
|
|
runtime.LockOSThread()
|
|
|
|
}
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-c:
|
|
|
|
cack <- true
|
|
|
|
return
|
|
|
|
default:
|
|
|
|
runtime.Gosched()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
c <- true
|
|
|
|
<-cack
|
|
|
|
}
|
|
|
|
|
2013-02-14 13:02:12 -07:00
|
|
|
func TestYieldLocked(t *testing.T) {
|
|
|
|
const N = 10
|
|
|
|
c := make(chan bool)
|
|
|
|
go func() {
|
|
|
|
runtime.LockOSThread()
|
|
|
|
for i := 0; i < N; i++ {
|
|
|
|
runtime.Gosched()
|
|
|
|
time.Sleep(time.Millisecond)
|
|
|
|
}
|
|
|
|
c <- true
|
|
|
|
// runtime.UnlockOSThread() is deliberately omitted
|
|
|
|
}()
|
|
|
|
<-c
|
|
|
|
}
|
|
|
|
|
2013-07-11 13:57:36 -06:00
|
|
|
func TestGoroutineParallelism(t *testing.T) {
|
2013-08-01 08:25:36 -06:00
|
|
|
P := 4
|
|
|
|
N := 10
|
|
|
|
if testing.Short() {
|
|
|
|
P = 3
|
|
|
|
N = 3
|
|
|
|
}
|
2013-07-11 13:57:36 -06:00
|
|
|
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P))
|
2014-07-15 00:30:12 -06:00
|
|
|
// If runtime triggers a forced GC during this test then it will deadlock,
|
|
|
|
// since the goroutines can't be stopped/preempted.
|
|
|
|
// So give this test as much time as possible.
|
|
|
|
runtime.GC()
|
2013-08-01 08:25:36 -06:00
|
|
|
for try := 0; try < N; try++ {
|
2013-07-11 13:57:36 -06:00
|
|
|
done := make(chan bool)
|
|
|
|
x := uint32(0)
|
|
|
|
for p := 0; p < P; p++ {
|
|
|
|
// Test that all P goroutines are scheduled at the same time
|
|
|
|
go func(p int) {
|
|
|
|
for i := 0; i < 3; i++ {
|
|
|
|
expected := uint32(P*i + p)
|
|
|
|
for atomic.LoadUint32(&x) != expected {
|
|
|
|
}
|
|
|
|
atomic.StoreUint32(&x, expected+1)
|
|
|
|
}
|
|
|
|
done <- true
|
|
|
|
}(p)
|
|
|
|
}
|
|
|
|
for p := 0; p < P; p++ {
|
|
|
|
<-done
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-14 13:02:12 -07:00
|
|
|
func TestBlockLocked(t *testing.T) {
|
|
|
|
const N = 10
|
|
|
|
c := make(chan bool)
|
|
|
|
go func() {
|
|
|
|
runtime.LockOSThread()
|
|
|
|
for i := 0; i < N; i++ {
|
|
|
|
c <- true
|
|
|
|
}
|
|
|
|
runtime.UnlockOSThread()
|
|
|
|
}()
|
|
|
|
for i := 0; i < N; i++ {
|
|
|
|
<-c
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-06-15 06:06:28 -06:00
|
|
|
func TestTimerFairness(t *testing.T) {
|
|
|
|
done := make(chan bool)
|
|
|
|
c := make(chan bool)
|
|
|
|
for i := 0; i < 2; i++ {
|
|
|
|
go func() {
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case c <- true:
|
|
|
|
case <-done:
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
|
|
|
|
timer := time.After(20 * time.Millisecond)
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-c:
|
|
|
|
case <-timer:
|
|
|
|
close(done)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestTimerFairness2(t *testing.T) {
|
|
|
|
done := make(chan bool)
|
|
|
|
c := make(chan bool)
|
|
|
|
for i := 0; i < 2; i++ {
|
|
|
|
go func() {
|
|
|
|
timer := time.After(20 * time.Millisecond)
|
|
|
|
var buf [1]byte
|
|
|
|
for {
|
|
|
|
syscall.Read(0, buf[0:0])
|
|
|
|
select {
|
|
|
|
case c <- true:
|
|
|
|
case <-c:
|
|
|
|
case <-timer:
|
|
|
|
done <- true
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
<-done
|
|
|
|
<-done
|
|
|
|
}
|
|
|
|
|
2013-06-28 07:52:17 -06:00
|
|
|
// The function is used to test preemption at split stack checks.
|
|
|
|
// Declaring a var avoids inlining at the call site.
|
|
|
|
var preempt = func() int {
|
|
|
|
var a [128]int
|
|
|
|
sum := 0
|
|
|
|
for _, v := range a {
|
|
|
|
sum += v
|
|
|
|
}
|
|
|
|
return sum
|
|
|
|
}
|
|
|
|
|
2013-07-18 15:22:26 -06:00
|
|
|
func TestPreemption(t *testing.T) {
|
|
|
|
// Test that goroutines are preempted at function calls.
|
2013-08-01 08:25:36 -06:00
|
|
|
N := 5
|
|
|
|
if testing.Short() {
|
|
|
|
N = 2
|
|
|
|
}
|
2013-07-18 15:22:26 -06:00
|
|
|
c := make(chan bool)
|
|
|
|
var x uint32
|
|
|
|
for g := 0; g < 2; g++ {
|
|
|
|
go func(g int) {
|
|
|
|
for i := 0; i < N; i++ {
|
|
|
|
for atomic.LoadUint32(&x) != uint32(g) {
|
|
|
|
preempt()
|
|
|
|
}
|
|
|
|
atomic.StoreUint32(&x, uint32(1-g))
|
|
|
|
}
|
|
|
|
c <- true
|
|
|
|
}(g)
|
|
|
|
}
|
|
|
|
<-c
|
|
|
|
<-c
|
|
|
|
}
|
|
|
|
|
2013-06-28 07:52:17 -06:00
|
|
|
func TestPreemptionGC(t *testing.T) {
|
|
|
|
// Test that pending GC preempts running goroutines.
|
2013-08-01 08:25:36 -06:00
|
|
|
P := 5
|
|
|
|
N := 10
|
|
|
|
if testing.Short() {
|
|
|
|
P = 3
|
|
|
|
N = 2
|
|
|
|
}
|
2013-06-28 07:52:17 -06:00
|
|
|
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(P + 1))
|
|
|
|
var stop uint32
|
|
|
|
for i := 0; i < P; i++ {
|
|
|
|
go func() {
|
|
|
|
for atomic.LoadUint32(&stop) == 0 {
|
|
|
|
preempt()
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
2013-08-01 08:25:36 -06:00
|
|
|
for i := 0; i < N; i++ {
|
2013-06-28 07:52:17 -06:00
|
|
|
runtime.Gosched()
|
|
|
|
runtime.GC()
|
|
|
|
}
|
|
|
|
atomic.StoreUint32(&stop, 1)
|
|
|
|
}
|
|
|
|
|
2014-01-20 23:24:42 -07:00
|
|
|
func TestGCFairness(t *testing.T) {
|
|
|
|
output := executeTest(t, testGCFairnessSource, nil)
|
|
|
|
want := "OK\n"
|
|
|
|
if output != want {
|
|
|
|
t.Fatalf("want %s, got %s\n", want, output)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const testGCFairnessSource = `
|
|
|
|
package main
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"os"
|
|
|
|
"runtime"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
|
|
|
func main() {
|
|
|
|
runtime.GOMAXPROCS(1)
|
|
|
|
f, err := os.Open("/dev/null")
|
|
|
|
if os.IsNotExist(err) {
|
|
|
|
// This test tests what it is intended to test only if writes are fast.
|
|
|
|
// If there is no /dev/null, we just don't execute the test.
|
2014-01-20 23:44:08 -07:00
|
|
|
fmt.Println("OK")
|
2014-01-20 23:24:42 -07:00
|
|
|
return
|
|
|
|
}
|
|
|
|
if err != nil {
|
|
|
|
fmt.Println(err)
|
|
|
|
os.Exit(1)
|
|
|
|
}
|
|
|
|
for i := 0; i < 2; i++ {
|
|
|
|
go func() {
|
|
|
|
for {
|
|
|
|
f.Write([]byte("."))
|
|
|
|
}
|
|
|
|
}()
|
|
|
|
}
|
|
|
|
time.Sleep(10 * time.Millisecond)
|
|
|
|
fmt.Println("OK")
|
|
|
|
}
|
|
|
|
`
|
|
|
|
|
2011-07-12 10:24:32 -06:00
|
|
|
func stackGrowthRecursive(i int) {
|
|
|
|
var pad [128]uint64
|
|
|
|
if i != 0 && pad[0] == 0 {
|
|
|
|
stackGrowthRecursive(i - 1)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
cmd/ld: fix large stack split for preempt check
If the stack frame size is larger than the known-unmapped region at the
bottom of the address space, then the stack split prologue cannot use the usual
condition:
SP - size >= stackguard
because SP - size may wrap around to a very large number.
Instead, if the stack frame is large, the prologue tests:
SP - stackguard >= size
(This ends up being a few instructions more expensive, so we don't do it always.)
Preemption requests register by setting stackguard to a very large value, so
that the first test (SP - size >= stackguard) cannot possibly succeed.
Unfortunately, that same very large value causes a wraparound in the
second test (SP - stackguard >= size), making it succeed incorrectly.
To avoid *that* wraparound, we have to amend the test:
stackguard != StackPreempt && SP - stackguard >= size
This test is only used for functions with large frames, which essentially
always split the stack, so the cost of the few instructions is noise.
This CL and CL 11085043 together fix the known issues with preemption,
at the beginning of a function, so we will be able to try turning it on again.
R=ken2
CC=golang-dev
https://golang.org/cl/11205043
2013-07-12 10:12:56 -06:00
|
|
|
func TestPreemptSplitBig(t *testing.T) {
|
|
|
|
if testing.Short() {
|
|
|
|
t.Skip("skipping in -short mode")
|
|
|
|
}
|
|
|
|
defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
|
|
|
|
stop := make(chan int)
|
|
|
|
go big(stop)
|
|
|
|
for i := 0; i < 3; i++ {
|
2013-07-15 15:02:42 -06:00
|
|
|
time.Sleep(10 * time.Microsecond) // let big start running
|
cmd/ld: fix large stack split for preempt check
If the stack frame size is larger than the known-unmapped region at the
bottom of the address space, then the stack split prologue cannot use the usual
condition:
SP - size >= stackguard
because SP - size may wrap around to a very large number.
Instead, if the stack frame is large, the prologue tests:
SP - stackguard >= size
(This ends up being a few instructions more expensive, so we don't do it always.)
Preemption requests register by setting stackguard to a very large value, so
that the first test (SP - size >= stackguard) cannot possibly succeed.
Unfortunately, that same very large value causes a wraparound in the
second test (SP - stackguard >= size), making it succeed incorrectly.
To avoid *that* wraparound, we have to amend the test:
stackguard != StackPreempt && SP - stackguard >= size
This test is only used for functions with large frames, which essentially
always split the stack, so the cost of the few instructions is noise.
This CL and CL 11085043 together fix the known issues with preemption,
at the beginning of a function, so we will be able to try turning it on again.
R=ken2
CC=golang-dev
https://golang.org/cl/11205043
2013-07-12 10:12:56 -06:00
|
|
|
runtime.GC()
|
|
|
|
}
|
|
|
|
close(stop)
|
|
|
|
}
|
|
|
|
|
|
|
|
func big(stop chan int) int {
|
|
|
|
n := 0
|
|
|
|
for {
|
|
|
|
// delay so that gc is sure to have asked for a preemption
|
2013-07-15 15:02:42 -06:00
|
|
|
for i := 0; i < 1e9; i++ {
|
cmd/ld: fix large stack split for preempt check
If the stack frame size is larger than the known-unmapped region at the
bottom of the address space, then the stack split prologue cannot use the usual
condition:
SP - size >= stackguard
because SP - size may wrap around to a very large number.
Instead, if the stack frame is large, the prologue tests:
SP - stackguard >= size
(This ends up being a few instructions more expensive, so we don't do it always.)
Preemption requests register by setting stackguard to a very large value, so
that the first test (SP - size >= stackguard) cannot possibly succeed.
Unfortunately, that same very large value causes a wraparound in the
second test (SP - stackguard >= size), making it succeed incorrectly.
To avoid *that* wraparound, we have to amend the test:
stackguard != StackPreempt && SP - stackguard >= size
This test is only used for functions with large frames, which essentially
always split the stack, so the cost of the few instructions is noise.
This CL and CL 11085043 together fix the known issues with preemption,
at the beginning of a function, so we will be able to try turning it on again.
R=ken2
CC=golang-dev
https://golang.org/cl/11205043
2013-07-12 10:12:56 -06:00
|
|
|
n++
|
|
|
|
}
|
|
|
|
|
|
|
|
// call bigframe, which used to miss the preemption in its prologue.
|
|
|
|
bigframe(stop)
|
|
|
|
|
|
|
|
// check if we've been asked to stop.
|
|
|
|
select {
|
|
|
|
case <-stop:
|
|
|
|
return n
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func bigframe(stop chan int) int {
|
|
|
|
// not splitting the stack will overflow.
|
|
|
|
// small will notice that it needs a stack split and will
|
|
|
|
// catch the overflow.
|
|
|
|
var x [8192]byte
|
|
|
|
return small(stop, &x)
|
|
|
|
}
|
|
|
|
|
|
|
|
func small(stop chan int, x *[8192]byte) int {
|
|
|
|
for i := range x {
|
|
|
|
x[i] = byte(i)
|
|
|
|
}
|
|
|
|
sum := 0
|
|
|
|
for i := range x {
|
|
|
|
sum += int(x[i])
|
|
|
|
}
|
|
|
|
|
|
|
|
// keep small from being a leaf function, which might
|
|
|
|
// make it not do any stack check at all.
|
|
|
|
nonleaf(stop)
|
|
|
|
|
|
|
|
return sum
|
|
|
|
}
|
|
|
|
|
|
|
|
func nonleaf(stop chan int) bool {
|
|
|
|
// do something that won't be inlined:
|
|
|
|
select {
|
|
|
|
case <-stop:
|
|
|
|
return true
|
|
|
|
default:
|
|
|
|
return false
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-02-22 21:48:02 -07:00
|
|
|
func TestSchedLocalQueue(t *testing.T) {
|
2014-09-06 11:07:23 -06:00
|
|
|
runtime.RunSchedLocalQueueTest()
|
2013-02-22 21:48:02 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestSchedLocalQueueSteal(t *testing.T) {
|
2014-09-06 11:07:23 -06:00
|
|
|
runtime.RunSchedLocalQueueStealTest()
|
2013-02-22 21:48:02 -07:00
|
|
|
}
|
|
|
|
|
2013-01-09 22:57:06 -07:00
|
|
|
func benchmarkStackGrowth(b *testing.B, rec int) {
|
2014-02-24 09:50:12 -07:00
|
|
|
b.RunParallel(func(pb *testing.PB) {
|
|
|
|
for pb.Next() {
|
|
|
|
stackGrowthRecursive(rec)
|
|
|
|
}
|
|
|
|
})
|
2011-07-12 10:24:32 -06:00
|
|
|
}
|
2011-07-19 09:01:17 -06:00
|
|
|
|
2013-01-09 22:57:06 -07:00
|
|
|
func BenchmarkStackGrowth(b *testing.B) {
|
|
|
|
benchmarkStackGrowth(b, 10)
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkStackGrowthDeep(b *testing.B) {
|
|
|
|
benchmarkStackGrowth(b, 1024)
|
|
|
|
}
|
|
|
|
|
2012-06-27 11:57:49 -06:00
|
|
|
func BenchmarkCreateGoroutines(b *testing.B) {
|
|
|
|
benchmarkCreateGoroutines(b, 1)
|
|
|
|
}
|
|
|
|
|
|
|
|
func BenchmarkCreateGoroutinesParallel(b *testing.B) {
|
|
|
|
benchmarkCreateGoroutines(b, runtime.GOMAXPROCS(-1))
|
|
|
|
}
|
|
|
|
|
|
|
|
func benchmarkCreateGoroutines(b *testing.B, procs int) {
|
|
|
|
c := make(chan bool)
|
|
|
|
var f func(n int)
|
|
|
|
f = func(n int) {
|
|
|
|
if n == 0 {
|
|
|
|
c <- true
|
|
|
|
return
|
|
|
|
}
|
|
|
|
go f(n - 1)
|
|
|
|
}
|
|
|
|
for i := 0; i < procs; i++ {
|
|
|
|
go f(b.N / procs)
|
|
|
|
}
|
|
|
|
for i := 0; i < procs; i++ {
|
|
|
|
<-c
|
|
|
|
}
|
|
|
|
}
|
2013-02-28 15:41:45 -07:00
|
|
|
|
|
|
|
type Matrix [][]float64
|
|
|
|
|
|
|
|
func BenchmarkMatmult(b *testing.B) {
|
|
|
|
b.StopTimer()
|
|
|
|
// matmult is O(N**3) but testing expects O(b.N),
|
|
|
|
// so we need to take cube root of b.N
|
|
|
|
n := int(math.Cbrt(float64(b.N))) + 1
|
|
|
|
A := makeMatrix(n)
|
|
|
|
B := makeMatrix(n)
|
|
|
|
C := makeMatrix(n)
|
|
|
|
b.StartTimer()
|
|
|
|
matmult(nil, A, B, C, 0, n, 0, n, 0, n, 8)
|
|
|
|
}
|
|
|
|
|
|
|
|
func makeMatrix(n int) Matrix {
|
|
|
|
m := make(Matrix, n)
|
|
|
|
for i := 0; i < n; i++ {
|
|
|
|
m[i] = make([]float64, n)
|
|
|
|
for j := 0; j < n; j++ {
|
|
|
|
m[i][j] = float64(i*n + j)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return m
|
|
|
|
}
|
|
|
|
|
|
|
|
func matmult(done chan<- struct{}, A, B, C Matrix, i0, i1, j0, j1, k0, k1, threshold int) {
|
|
|
|
di := i1 - i0
|
|
|
|
dj := j1 - j0
|
|
|
|
dk := k1 - k0
|
|
|
|
if di >= dj && di >= dk && di >= threshold {
|
|
|
|
// divide in two by y axis
|
|
|
|
mi := i0 + di/2
|
|
|
|
done1 := make(chan struct{}, 1)
|
|
|
|
go matmult(done1, A, B, C, i0, mi, j0, j1, k0, k1, threshold)
|
|
|
|
matmult(nil, A, B, C, mi, i1, j0, j1, k0, k1, threshold)
|
|
|
|
<-done1
|
|
|
|
} else if dj >= dk && dj >= threshold {
|
|
|
|
// divide in two by x axis
|
|
|
|
mj := j0 + dj/2
|
|
|
|
done1 := make(chan struct{}, 1)
|
|
|
|
go matmult(done1, A, B, C, i0, i1, j0, mj, k0, k1, threshold)
|
|
|
|
matmult(nil, A, B, C, i0, i1, mj, j1, k0, k1, threshold)
|
|
|
|
<-done1
|
|
|
|
} else if dk >= threshold {
|
|
|
|
// divide in two by "k" axis
|
|
|
|
// deliberately not parallel because of data races
|
|
|
|
mk := k0 + dk/2
|
|
|
|
matmult(nil, A, B, C, i0, i1, j0, j1, k0, mk, threshold)
|
|
|
|
matmult(nil, A, B, C, i0, i1, j0, j1, mk, k1, threshold)
|
|
|
|
} else {
|
|
|
|
// the matrices are small enough, compute directly
|
|
|
|
for i := i0; i < i1; i++ {
|
|
|
|
for j := j0; j < j1; j++ {
|
|
|
|
for k := k0; k < k1; k++ {
|
|
|
|
C[i][j] += A[i][k] * B[k][j]
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if done != nil {
|
|
|
|
done <- struct{}{}
|
|
|
|
}
|
|
|
|
}
|