...
Run Format

Source file src/runtime/profbuf_test.go

Documentation: runtime

     1  // Copyright 2017 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  	"reflect"
     9  	. "runtime"
    10  	"testing"
    11  	"time"
    12  	"unsafe"
    13  )
    14  
    15  func TestProfBuf(t *testing.T) {
    16  	const hdrSize = 2
    17  
    18  	write := func(t *testing.T, b *ProfBuf, tag unsafe.Pointer, now int64, hdr []uint64, stk []uintptr) {
    19  		b.Write(&tag, now, hdr, stk)
    20  	}
    21  	read := func(t *testing.T, b *ProfBuf, data []uint64, tags []unsafe.Pointer) {
    22  		rdata, rtags, eof := b.Read(ProfBufNonBlocking)
    23  		if !reflect.DeepEqual(rdata, data) || !reflect.DeepEqual(rtags, tags) {
    24  			t.Fatalf("unexpected profile read:\nhave data %#x\nwant data %#x\nhave tags %#x\nwant tags %#x", rdata, data, rtags, tags)
    25  		}
    26  		if eof {
    27  			t.Fatalf("unexpected eof")
    28  		}
    29  	}
    30  	readBlock := func(t *testing.T, b *ProfBuf, data []uint64, tags []unsafe.Pointer) func() {
    31  		c := make(chan int)
    32  		go func() {
    33  			eof := data == nil
    34  			rdata, rtags, reof := b.Read(ProfBufBlocking)
    35  			if !reflect.DeepEqual(rdata, data) || !reflect.DeepEqual(rtags, tags) || reof != eof {
    36  				// Errorf, not Fatalf, because called in goroutine.
    37  				t.Errorf("unexpected profile read:\nhave data %#x\nwant data %#x\nhave tags %#x\nwant tags %#x\nhave eof=%v, want %v", rdata, data, rtags, tags, reof, eof)
    38  			}
    39  			c <- 1
    40  		}()
    41  		time.Sleep(10 * time.Millisecond) // let goroutine run and block
    42  		return func() {
    43  			select {
    44  			case <-c:
    45  			case <-time.After(1 * time.Second):
    46  				t.Fatalf("timeout waiting for blocked read")
    47  			}
    48  		}
    49  	}
    50  	readEOF := func(t *testing.T, b *ProfBuf) {
    51  		rdata, rtags, eof := b.Read(ProfBufBlocking)
    52  		if rdata != nil || rtags != nil || !eof {
    53  			t.Errorf("unexpected profile read: %#x, %#x, eof=%v; want nil, nil, eof=true", rdata, rtags, eof)
    54  		}
    55  		rdata, rtags, eof = b.Read(ProfBufNonBlocking)
    56  		if rdata != nil || rtags != nil || !eof {
    57  			t.Errorf("unexpected profile read (non-blocking): %#x, %#x, eof=%v; want nil, nil, eof=true", rdata, rtags, eof)
    58  		}
    59  	}
    60  
    61  	myTags := make([]byte, 100)
    62  	t.Logf("myTags is %p", &myTags[0])
    63  
    64  	t.Run("BasicWriteRead", func(t *testing.T) {
    65  		b := NewProfBuf(2, 11, 1)
    66  		write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
    67  		read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9}, []unsafe.Pointer{unsafe.Pointer(&myTags[0])})
    68  		read(t, b, nil, nil) // release data returned by previous read
    69  		write(t, b, unsafe.Pointer(&myTags[2]), 99, []uint64{101, 102}, []uintptr{201, 202, 203, 204})
    70  		read(t, b, []uint64{8, 99, 101, 102, 201, 202, 203, 204}, []unsafe.Pointer{unsafe.Pointer(&myTags[2])})
    71  	})
    72  
    73  	t.Run("ReadMany", func(t *testing.T) {
    74  		b := NewProfBuf(2, 50, 50)
    75  		write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
    76  		write(t, b, unsafe.Pointer(&myTags[2]), 99, []uint64{101, 102}, []uintptr{201, 202, 203, 204})
    77  		write(t, b, unsafe.Pointer(&myTags[1]), 500, []uint64{502, 504}, []uintptr{506})
    78  		read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 99, 101, 102, 201, 202, 203, 204, 5, 500, 502, 504, 506}, []unsafe.Pointer{unsafe.Pointer(&myTags[0]), unsafe.Pointer(&myTags[2]), unsafe.Pointer(&myTags[1])})
    79  	})
    80  
    81  	t.Run("ReadManyShortData", func(t *testing.T) {
    82  		b := NewProfBuf(2, 50, 50)
    83  		write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
    84  		write(t, b, unsafe.Pointer(&myTags[2]), 99, []uint64{101, 102}, []uintptr{201, 202, 203, 204})
    85  		read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 99, 101, 102, 201, 202, 203, 204}, []unsafe.Pointer{unsafe.Pointer(&myTags[0]), unsafe.Pointer(&myTags[2])})
    86  	})
    87  
    88  	t.Run("ReadManyShortTags", func(t *testing.T) {
    89  		b := NewProfBuf(2, 50, 50)
    90  		write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
    91  		write(t, b, unsafe.Pointer(&myTags[2]), 99, []uint64{101, 102}, []uintptr{201, 202, 203, 204})
    92  		read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 8, 99, 101, 102, 201, 202, 203, 204}, []unsafe.Pointer{unsafe.Pointer(&myTags[0]), unsafe.Pointer(&myTags[2])})
    93  	})
    94  
    95  	t.Run("ReadAfterOverflow1", func(t *testing.T) {
    96  		// overflow record synthesized by write
    97  		b := NewProfBuf(2, 16, 5)
    98  		write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})           // uses 10
    99  		read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9}, []unsafe.Pointer{unsafe.Pointer(&myTags[0])}) // reads 10 but still in use until next read
   100  		write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5})                       // uses 6
   101  		read(t, b, []uint64{6, 1, 2, 3, 4, 5}, []unsafe.Pointer{unsafe.Pointer(&myTags[0])})              // reads 6 but still in use until next read
   102  		// now 10 available
   103  		write(t, b, unsafe.Pointer(&myTags[2]), 99, []uint64{101, 102}, []uintptr{201, 202, 203, 204, 205, 206, 207, 208, 209}) // no room
   104  		for i := 0; i < 299; i++ {
   105  			write(t, b, unsafe.Pointer(&myTags[3]), int64(100+i), []uint64{101, 102}, []uintptr{201, 202, 203, 204}) // no room for overflow+this record
   106  		}
   107  		write(t, b, unsafe.Pointer(&myTags[1]), 500, []uint64{502, 504}, []uintptr{506}) // room for overflow+this record
   108  		read(t, b, []uint64{5, 99, 0, 0, 300, 5, 500, 502, 504, 506}, []unsafe.Pointer{nil, unsafe.Pointer(&myTags[1])})
   109  	})
   110  
   111  	t.Run("ReadAfterOverflow2", func(t *testing.T) {
   112  		// overflow record synthesized by read
   113  		b := NewProfBuf(2, 16, 5)
   114  		write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
   115  		write(t, b, unsafe.Pointer(&myTags[2]), 99, []uint64{101, 102}, []uintptr{201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213})
   116  		for i := 0; i < 299; i++ {
   117  			write(t, b, unsafe.Pointer(&myTags[3]), 100, []uint64{101, 102}, []uintptr{201, 202, 203, 204})
   118  		}
   119  		read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9}, []unsafe.Pointer{unsafe.Pointer(&myTags[0])}) // reads 10 but still in use until next read
   120  		write(t, b, unsafe.Pointer(&myTags[1]), 500, []uint64{502, 504}, []uintptr{})                     // still overflow
   121  		read(t, b, []uint64{5, 99, 0, 0, 301}, []unsafe.Pointer{nil})                                     // overflow synthesized by read
   122  		write(t, b, unsafe.Pointer(&myTags[1]), 500, []uint64{502, 505}, []uintptr{506})                  // written
   123  		read(t, b, []uint64{5, 500, 502, 505, 506}, []unsafe.Pointer{unsafe.Pointer(&myTags[1])})
   124  	})
   125  
   126  	t.Run("ReadAtEndAfterOverflow", func(t *testing.T) {
   127  		b := NewProfBuf(2, 12, 5)
   128  		write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
   129  		write(t, b, unsafe.Pointer(&myTags[2]), 99, []uint64{101, 102}, []uintptr{201, 202, 203, 204})
   130  		for i := 0; i < 299; i++ {
   131  			write(t, b, unsafe.Pointer(&myTags[3]), 100, []uint64{101, 102}, []uintptr{201, 202, 203, 204})
   132  		}
   133  		read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9}, []unsafe.Pointer{unsafe.Pointer(&myTags[0])})
   134  		read(t, b, []uint64{5, 99, 0, 0, 300}, []unsafe.Pointer{nil})
   135  		write(t, b, unsafe.Pointer(&myTags[1]), 500, []uint64{502, 504}, []uintptr{506})
   136  		read(t, b, []uint64{5, 500, 502, 504, 506}, []unsafe.Pointer{unsafe.Pointer(&myTags[1])})
   137  	})
   138  
   139  	t.Run("BlockingWriteRead", func(t *testing.T) {
   140  		b := NewProfBuf(2, 11, 1)
   141  		wait := readBlock(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9}, []unsafe.Pointer{unsafe.Pointer(&myTags[0])})
   142  		write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
   143  		wait()
   144  		wait = readBlock(t, b, []uint64{8, 99, 101, 102, 201, 202, 203, 204}, []unsafe.Pointer{unsafe.Pointer(&myTags[2])})
   145  		time.Sleep(10 * time.Millisecond)
   146  		write(t, b, unsafe.Pointer(&myTags[2]), 99, []uint64{101, 102}, []uintptr{201, 202, 203, 204})
   147  		wait()
   148  		wait = readBlock(t, b, nil, nil)
   149  		b.Close()
   150  		wait()
   151  		wait = readBlock(t, b, nil, nil)
   152  		wait()
   153  		readEOF(t, b)
   154  	})
   155  
   156  	t.Run("DataWraparound", func(t *testing.T) {
   157  		b := NewProfBuf(2, 16, 1024)
   158  		for i := 0; i < 10; i++ {
   159  			write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
   160  			read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9}, []unsafe.Pointer{unsafe.Pointer(&myTags[0])})
   161  			read(t, b, nil, nil) // release data returned by previous read
   162  		}
   163  	})
   164  
   165  	t.Run("TagWraparound", func(t *testing.T) {
   166  		b := NewProfBuf(2, 1024, 2)
   167  		for i := 0; i < 10; i++ {
   168  			write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
   169  			read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9}, []unsafe.Pointer{unsafe.Pointer(&myTags[0])})
   170  			read(t, b, nil, nil) // release data returned by previous read
   171  		}
   172  	})
   173  
   174  	t.Run("BothWraparound", func(t *testing.T) {
   175  		b := NewProfBuf(2, 16, 2)
   176  		for i := 0; i < 10; i++ {
   177  			write(t, b, unsafe.Pointer(&myTags[0]), 1, []uint64{2, 3}, []uintptr{4, 5, 6, 7, 8, 9})
   178  			read(t, b, []uint64{10, 1, 2, 3, 4, 5, 6, 7, 8, 9}, []unsafe.Pointer{unsafe.Pointer(&myTags[0])})
   179  			read(t, b, nil, nil) // release data returned by previous read
   180  		}
   181  	})
   182  }
   183  

View as plain text