OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgo/] [go/] [runtime/] [proc_test.go] - Blame information for rev 801

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 747 jeremybenn 
// Copyright 2011 The Go Authors. All rights reserved.
2 
// Use of this source code is governed by a BSD-style
3 
// license that can be found in the LICENSE file.
4 
 
5 
package runtime_test
6 
 
7 
import (
8 
        "runtime"
9 
        "sync/atomic"
10 
        "testing"
11 
)
12 
 
13 
var stop = make(chan bool, 1)
14 
 
15 
func perpetuumMobile() {
16 
        select {
17 
        case <-stop:
18 
        default:
19 
                go perpetuumMobile()
20 
        }
21 
}
22 
 
23 
func TestStopTheWorldDeadlock(t *testing.T) {
24 
        if testing.Short() {
25 
                t.Logf("skipping during short test")
26 
                return
27 
        }
28 
        maxprocs := runtime.GOMAXPROCS(3)
29 
        compl := make(chan bool, 2)
30 
        go func() {
31 
                for i := 0; i != 1000; i += 1 {
32 
                        runtime.GC()
33 
                }
34 
                compl <- true
35 
        }()
36 
        go func() {
37 
                for i := 0; i != 1000; i += 1 {
38 
                        runtime.GOMAXPROCS(3)
39 
                }
40 
                compl <- true
41 
        }()
42 
        go perpetuumMobile()
43 
        <-compl
44 
        <-compl
45 
        stop <- true
46 
        runtime.GOMAXPROCS(maxprocs)
47 
}
48 
 
49 
func stackGrowthRecursive(i int) {
50 
        var pad [128]uint64
51 
        if i != 0 && pad[0] == 0 {
52 
                stackGrowthRecursive(i - 1)
53 
        }
54 
}
55 
 
56 
func BenchmarkStackGrowth(b *testing.B) {
57 
        const CallsPerSched = 1000
58 
        procs := runtime.GOMAXPROCS(-1)
59 
        N := int32(b.N / CallsPerSched)
60 
        c := make(chan bool, procs)
61 
        for p := 0; p < procs; p++ {
62 
                go func() {
63 
                        for atomic.AddInt32(&N, -1) >= 0 {
64 
                                runtime.Gosched()
65 
                                for g := 0; g < CallsPerSched; g++ {
66 
                                        stackGrowthRecursive(10)
67 
                                }
68 
                        }
69 
                        c <- true
70 
                }()
71 
        }
72 
        for p := 0; p < procs; p++ {
73 
                <-c
74 
        }
75 
}
76 
 
77 
func BenchmarkSyscall(b *testing.B) {
78 
        const CallsPerSched = 1000
79 
        procs := runtime.GOMAXPROCS(-1)
80 
        N := int32(b.N / CallsPerSched)
81 
        c := make(chan bool, procs)
82 
        for p := 0; p < procs; p++ {
83 
                go func() {
84 
                        for atomic.AddInt32(&N, -1) >= 0 {
85 
                                runtime.Gosched()
86 
                                for g := 0; g < CallsPerSched; g++ {
87 
                                        runtime.Entersyscall()
88 
                                        runtime.Exitsyscall()
89 
                                }
90 
                        }
91 
                        c <- true
92 
                }()
93 
        }
94 
        for p := 0; p < procs; p++ {
95 
                <-c
96 
        }
97 
}
98 
 
99 
func BenchmarkSyscallWork(b *testing.B) {
100 
        const CallsPerSched = 1000
101 
        const LocalWork = 100
102 
        procs := runtime.GOMAXPROCS(-1)
103 
        N := int32(b.N / CallsPerSched)
104 
        c := make(chan bool, procs)
105 
        for p := 0; p < procs; p++ {
106 
                go func() {
107 
                        foo := 42
108 
                        for atomic.AddInt32(&N, -1) >= 0 {
109 
                                runtime.Gosched()
110 
                                for g := 0; g < CallsPerSched; g++ {
111 
                                        runtime.Entersyscall()
112 
                                        for i := 0; i < LocalWork; i++ {
113 
                                                foo *= 2
114 
                                                foo /= 2
115 
                                        }
116 
                                        runtime.Exitsyscall()
117 
                                }
118 
                        }
119 
                        c <- foo == 42
120 
                }()
121 
        }
122 
        for p := 0; p < procs; p++ {
123 
                <-c
124 
        }
125 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.