github.com/peggyl/go@v0.0.0-20151008231540-ae315999c2d5/src/runtime/export_test.go (about)

     1  // Copyright 2010 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  // Export guts for testing.
     6  
     7  package runtime
     8  
     9  import "unsafe"
    10  
    11  var Fadd64 = fadd64
    12  var Fsub64 = fsub64
    13  var Fmul64 = fmul64
    14  var Fdiv64 = fdiv64
    15  var F64to32 = f64to32
    16  var F32to64 = f32to64
    17  var Fcmp64 = fcmp64
    18  var Fintto64 = fintto64
    19  var F64toint = f64toint
    20  var Sqrt = sqrt
    21  
    22  var Entersyscall = entersyscall
    23  var Exitsyscall = exitsyscall
    24  var LockedOSThread = lockedOSThread
    25  var Xadduintptr = xadduintptr
    26  
    27  var FuncPC = funcPC
    28  
    29  var Fastlog2 = fastlog2
    30  
    31  type LFNode struct {
    32  	Next    uint64
    33  	Pushcnt uintptr
    34  }
    35  
    36  func LFStackPush(head *uint64, node *LFNode) {
    37  	lfstackpush(head, (*lfnode)(unsafe.Pointer(node)))
    38  }
    39  
    40  func LFStackPop(head *uint64) *LFNode {
    41  	return (*LFNode)(unsafe.Pointer(lfstackpop(head)))
    42  }
    43  
    44  type ParFor struct {
    45  	body   func(*ParFor, uint32)
    46  	done   uint32
    47  	Nthr   uint32
    48  	thrseq uint32
    49  	Cnt    uint32
    50  	wait   bool
    51  }
    52  
    53  func NewParFor(nthrmax uint32) *ParFor {
    54  	var desc *ParFor
    55  	systemstack(func() {
    56  		desc = (*ParFor)(unsafe.Pointer(parforalloc(nthrmax)))
    57  	})
    58  	return desc
    59  }
    60  
    61  func ParForSetup(desc *ParFor, nthr, n uint32, wait bool, body func(*ParFor, uint32)) {
    62  	systemstack(func() {
    63  		parforsetup((*parfor)(unsafe.Pointer(desc)), nthr, n, wait,
    64  			*(*func(*parfor, uint32))(unsafe.Pointer(&body)))
    65  	})
    66  }
    67  
    68  func ParForDo(desc *ParFor) {
    69  	systemstack(func() {
    70  		parfordo((*parfor)(unsafe.Pointer(desc)))
    71  	})
    72  }
    73  
    74  func ParForIters(desc *ParFor, tid uint32) (uint32, uint32) {
    75  	desc1 := (*parfor)(unsafe.Pointer(desc))
    76  	pos := desc1.thr[tid].pos
    77  	return uint32(pos), uint32(pos >> 32)
    78  }
    79  
    80  func GCMask(x interface{}) (ret []byte) {
    81  	systemstack(func() {
    82  		ret = getgcmask(x)
    83  	})
    84  	return
    85  }
    86  
    87  func RunSchedLocalQueueTest() {
    88  	testSchedLocalQueue()
    89  }
    90  func RunSchedLocalQueueStealTest() {
    91  	testSchedLocalQueueSteal()
    92  }
    93  
    94  var StringHash = stringHash
    95  var BytesHash = bytesHash
    96  var Int32Hash = int32Hash
    97  var Int64Hash = int64Hash
    98  var EfaceHash = efaceHash
    99  var IfaceHash = ifaceHash
   100  var MemclrBytes = memclrBytes
   101  
   102  var HashLoad = &hashLoad
   103  
   104  // entry point for testing
   105  func GostringW(w []uint16) (s string) {
   106  	systemstack(func() {
   107  		s = gostringw(&w[0])
   108  	})
   109  	return
   110  }
   111  
   112  var Gostringnocopy = gostringnocopy
   113  var Maxstring = &maxstring
   114  
   115  type Uintreg uintreg
   116  
   117  var Open = open
   118  var Close = closefd
   119  var Read = read
   120  var Write = write
   121  
   122  func Envs() []string     { return envs }
   123  func SetEnvs(e []string) { envs = e }
   124  
   125  var BigEndian = _BigEndian
   126  
   127  // For benchmarking.
   128  
   129  func BenchSetType(n int, x interface{}) {
   130  	e := *(*eface)(unsafe.Pointer(&x))
   131  	t := e._type
   132  	var size uintptr
   133  	var p unsafe.Pointer
   134  	switch t.kind & kindMask {
   135  	case _KindPtr:
   136  		t = (*ptrtype)(unsafe.Pointer(t)).elem
   137  		size = t.size
   138  		p = e.data
   139  	case _KindSlice:
   140  		slice := *(*struct {
   141  			ptr      unsafe.Pointer
   142  			len, cap uintptr
   143  		})(e.data)
   144  		t = (*slicetype)(unsafe.Pointer(t)).elem
   145  		size = t.size * slice.len
   146  		p = slice.ptr
   147  	}
   148  	allocSize := roundupsize(size)
   149  	systemstack(func() {
   150  		for i := 0; i < n; i++ {
   151  			heapBitsSetType(uintptr(p), allocSize, size, t)
   152  		}
   153  	})
   154  }
   155  
   156  const PtrSize = ptrSize
   157  
   158  var TestingAssertE2I2GC = &testingAssertE2I2GC
   159  var TestingAssertE2T2GC = &testingAssertE2T2GC
   160  
   161  var ForceGCPeriod = &forcegcperiod