Source file test/gcgort.go

     1  // run
     2  
     3  // Copyright 2018 The Go Authors. All rights reserved.
     4  // Use of this source code is governed by a BSD-style
     5  // license that can be found in the LICENSE file.
     6  
     7  // Test independent goroutines modifying a comprehensive
     8  // variety of vars during aggressive garbage collection.
     9  
    10  // The point is to catch GC regressions like fixedbugs/issue22781.go
    11  
    12  package main
    13  
    14  import (
    15  	"errors"
    16  	"runtime"
    17  	"runtime/debug"
    18  	"sync"
    19  )
    20  
    21  const (
    22  	goroutines = 8
    23  	allocs     = 8
    24  	mods       = 8
    25  
    26  	length = 9
    27  )
    28  
    29  func main() {
    30  	debug.SetGCPercent(1)
    31  	var wg sync.WaitGroup
    32  	for i := 0; i < goroutines; i++ {
    33  		for _, t := range types {
    34  			err := t.valid()
    35  			if err != nil {
    36  				panic(err)
    37  			}
    38  			wg.Add(1)
    39  			go func(f modifier) {
    40  				var wg2 sync.WaitGroup
    41  				for j := 0; j < allocs; j++ {
    42  					wg2.Add(1)
    43  					go func() {
    44  						f.t()
    45  						wg2.Done()
    46  					}()
    47  					wg2.Add(1)
    48  					go func() {
    49  						f.pointerT()
    50  						wg2.Done()
    51  					}()
    52  					wg2.Add(1)
    53  					go func() {
    54  						f.arrayT()
    55  						wg2.Done()
    56  					}()
    57  					wg2.Add(1)
    58  					go func() {
    59  						f.sliceT()
    60  						wg2.Done()
    61  					}()
    62  					wg2.Add(1)
    63  					go func() {
    64  						f.mapT()
    65  						wg2.Done()
    66  					}()
    67  					wg2.Add(1)
    68  					go func() {
    69  						f.mapPointerKeyT()
    70  						wg2.Done()
    71  					}()
    72  					wg2.Add(1)
    73  					go func() {
    74  						f.chanT()
    75  						wg2.Done()
    76  					}()
    77  					wg2.Add(1)
    78  					go func() {
    79  						f.interfaceT()
    80  						wg2.Done()
    81  					}()
    82  				}
    83  				wg2.Wait()
    84  				wg.Done()
    85  			}(t)
    86  		}
    87  	}
    88  	wg.Wait()
    89  }
    90  
    91  type modifier struct {
    92  	name           string
    93  	t              func()
    94  	pointerT       func()
    95  	arrayT         func()
    96  	sliceT         func()
    97  	mapT           func()
    98  	mapPointerKeyT func()
    99  	chanT          func()
   100  	interfaceT     func()
   101  }
   102  
   103  func (a modifier) valid() error {
   104  	switch {
   105  	case a.name == "":
   106  		return errors.New("modifier without name")
   107  	case a.t == nil:
   108  		return errors.New(a.name + " missing t")
   109  	case a.pointerT == nil:
   110  		return errors.New(a.name + " missing pointerT")
   111  	case a.arrayT == nil:
   112  		return errors.New(a.name + " missing arrayT")
   113  	case a.sliceT == nil:
   114  		return errors.New(a.name + " missing sliceT")
   115  	case a.mapT == nil:
   116  		return errors.New(a.name + " missing mapT")
   117  	case a.mapPointerKeyT == nil:
   118  		return errors.New(a.name + " missing mapPointerKeyT")
   119  	case a.chanT == nil:
   120  		return errors.New(a.name + " missing chanT")
   121  	case a.interfaceT == nil:
   122  		return errors.New(a.name + " missing interfaceT")
   123  	default:
   124  		return nil
   125  	}
   126  }
   127  
   128  var types = []modifier{
   129  	modifier{
   130  		name: "bool",
   131  		t: func() {
   132  			var a bool
   133  			for i := 0; i < mods; i++ {
   134  				a = !a
   135  				runtime.Gosched()
   136  			}
   137  		},
   138  		pointerT: func() {
   139  			a := func() *bool { return new(bool) }()
   140  			for i := 0; i < mods; i++ {
   141  				*a = !*a
   142  				runtime.Gosched()
   143  			}
   144  		},
   145  		arrayT: func() {
   146  			a := [length]bool{}
   147  			for i := 0; i < mods; i++ {
   148  				for j := 0; j < len(a); j++ {
   149  					a[j] = !a[j]
   150  					runtime.Gosched()
   151  				}
   152  			}
   153  		},
   154  		sliceT: func() {
   155  			a := make([]bool, length)
   156  			for i := 0; i < mods; i++ {
   157  				for j := 0; j < len(a); j++ {
   158  					a[j] = !a[j]
   159  					runtime.Gosched()
   160  				}
   161  			}
   162  		},
   163  		mapT: func() {
   164  			a := make(map[bool]bool)
   165  			for i := 0; i < mods; i++ {
   166  				a[false] = !a[false]
   167  				a[true] = !a[true]
   168  				runtime.Gosched()
   169  			}
   170  		},
   171  		mapPointerKeyT: func() {
   172  			a := make(map[*bool]bool)
   173  			for i := 0; i < length; i++ {
   174  				a[new(bool)] = false
   175  				runtime.Gosched()
   176  			}
   177  			for i := 0; i < mods; i++ {
   178  				for k, v := range a {
   179  					a[k] = !v
   180  					runtime.Gosched()
   181  				}
   182  			}
   183  		},
   184  		chanT: func() {
   185  			a := make(chan bool)
   186  			for i := 0; i < mods; i++ {
   187  				go func() { a <- false }()
   188  				<-a
   189  				runtime.Gosched()
   190  			}
   191  		},
   192  		interfaceT: func() {
   193  			a := interface{}(bool(false))
   194  			for i := 0; i < mods; i++ {
   195  				a = !a.(bool)
   196  				runtime.Gosched()
   197  			}
   198  		},
   199  	},
   200  	modifier{
   201  		name: "uint8",
   202  		t: func() {
   203  			var u uint8
   204  			for i := 0; i < mods; i++ {
   205  				u++
   206  				runtime.Gosched()
   207  			}
   208  		},
   209  		pointerT: func() {
   210  			a := func() *uint8 { return new(uint8) }()
   211  			for i := 0; i < mods; i++ {
   212  				*a++
   213  				runtime.Gosched()
   214  			}
   215  		},
   216  		arrayT: func() {
   217  			a := [length]uint8{}
   218  			for i := 0; i < mods; i++ {
   219  				for j := 0; j < len(a); j++ {
   220  					a[j]++
   221  					runtime.Gosched()
   222  				}
   223  			}
   224  		},
   225  		sliceT: func() {
   226  			a := make([]uint8, length)
   227  			for i := 0; i < mods; i++ {
   228  				for j := 0; j < len(a); j++ {
   229  					a[j]++
   230  					runtime.Gosched()
   231  				}
   232  			}
   233  		},
   234  		mapT: func() {
   235  			a := make(map[uint8]uint8)
   236  			for i := 0; i < length; i++ {
   237  				a[uint8(i)] = uint8(i)
   238  				runtime.Gosched()
   239  			}
   240  			for i := 0; i < mods; i++ {
   241  				for k, _ := range a {
   242  					a[k]++
   243  				}
   244  				runtime.Gosched()
   245  			}
   246  		},
   247  		mapPointerKeyT: func() {
   248  			a := make(map[*uint8]uint8)
   249  			for i := 0; i < length; i++ {
   250  				a[new(uint8)] = uint8(i)
   251  				runtime.Gosched()
   252  			}
   253  			for i := 0; i < mods; i++ {
   254  				for k, _ := range a {
   255  					a[k]++
   256  					runtime.Gosched()
   257  				}
   258  			}
   259  		},
   260  		chanT: func() {
   261  			a := make(chan uint8)
   262  			for i := 0; i < mods; i++ {
   263  				go func() { a <- uint8(i) }()
   264  				<-a
   265  				runtime.Gosched()
   266  			}
   267  		},
   268  		interfaceT: func() {
   269  			a := interface{}(uint8(0))
   270  			for i := 0; i < mods; i++ {
   271  				a = a.(uint8) + 1
   272  				runtime.Gosched()
   273  			}
   274  		},
   275  	},
   276  	modifier{
   277  		name: "uint16",
   278  		t: func() {
   279  			var u uint16
   280  			for i := 0; i < mods; i++ {
   281  				u++
   282  				runtime.Gosched()
   283  			}
   284  		},
   285  		pointerT: func() {
   286  			a := func() *uint16 { return new(uint16) }()
   287  			for i := 0; i < mods; i++ {
   288  				*a++
   289  				runtime.Gosched()
   290  			}
   291  		},
   292  		arrayT: func() {
   293  			a := [length]uint16{}
   294  			for i := 0; i < mods; i++ {
   295  				for j := 0; j < len(a); j++ {
   296  					a[j]++
   297  					runtime.Gosched()
   298  				}
   299  			}
   300  		},
   301  		sliceT: func() {
   302  			a := make([]uint16, length)
   303  			for i := 0; i < mods; i++ {
   304  				for j := 0; j < len(a); j++ {
   305  					a[j]++
   306  					runtime.Gosched()
   307  				}
   308  			}
   309  		},
   310  		mapT: func() {
   311  			a := make(map[uint16]uint16)
   312  			for i := 0; i < length; i++ {
   313  				a[uint16(i)] = uint16(i)
   314  				runtime.Gosched()
   315  			}
   316  			for i := 0; i < mods; i++ {
   317  				for k, _ := range a {
   318  					a[k]++
   319  				}
   320  				runtime.Gosched()
   321  			}
   322  		},
   323  		mapPointerKeyT: func() {
   324  			a := make(map[*uint16]uint16)
   325  			for i := 0; i < length; i++ {
   326  				a[new(uint16)] = uint16(i)
   327  				runtime.Gosched()
   328  			}
   329  			for i := 0; i < mods; i++ {
   330  				for k, _ := range a {
   331  					a[k]++
   332  					runtime.Gosched()
   333  				}
   334  			}
   335  		},
   336  		chanT: func() {
   337  			a := make(chan uint16)
   338  			for i := 0; i < mods; i++ {
   339  				go func() { a <- uint16(i) }()
   340  				<-a
   341  				runtime.Gosched()
   342  			}
   343  		},
   344  		interfaceT: func() {
   345  			a := interface{}(uint16(0))
   346  			for i := 0; i < mods; i++ {
   347  				a = a.(uint16) + 1
   348  				runtime.Gosched()
   349  			}
   350  		},
   351  	},
   352  	modifier{
   353  		name: "uint32",
   354  		t: func() {
   355  			var u uint32
   356  			for i := 0; i < mods; i++ {
   357  				u++
   358  				runtime.Gosched()
   359  			}
   360  		},
   361  		pointerT: func() {
   362  			a := func() *uint32 { return new(uint32) }()
   363  			for i := 0; i < mods; i++ {
   364  				*a++
   365  				runtime.Gosched()
   366  			}
   367  		},
   368  		arrayT: func() {
   369  			a := [length]uint32{}
   370  			for i := 0; i < mods; i++ {
   371  				for j := 0; j < len(a); j++ {
   372  					a[j]++
   373  					runtime.Gosched()
   374  				}
   375  			}
   376  		},
   377  		sliceT: func() {
   378  			a := make([]uint32, length)
   379  			for i := 0; i < mods; i++ {
   380  				for j := 0; j < len(a); j++ {
   381  					a[j]++
   382  					runtime.Gosched()
   383  				}
   384  			}
   385  		},
   386  		mapT: func() {
   387  			a := make(map[uint32]uint32)
   388  			for i := 0; i < length; i++ {
   389  				a[uint32(i)] = uint32(i)
   390  				runtime.Gosched()
   391  			}
   392  			for i := 0; i < mods; i++ {
   393  				for k, _ := range a {
   394  					a[k]++
   395  				}
   396  				runtime.Gosched()
   397  			}
   398  		},
   399  		mapPointerKeyT: func() {
   400  			a := make(map[*uint32]uint32)
   401  			for i := 0; i < length; i++ {
   402  				a[new(uint32)] = uint32(i)
   403  				runtime.Gosched()
   404  			}
   405  			for i := 0; i < mods; i++ {
   406  				for k, _ := range a {
   407  					a[k]++
   408  					runtime.Gosched()
   409  				}
   410  			}
   411  		},
   412  		chanT: func() {
   413  			a := make(chan uint32)
   414  			for i := 0; i < mods; i++ {
   415  				go func() { a <- uint32(i) }()
   416  				<-a
   417  				runtime.Gosched()
   418  			}
   419  		},
   420  		interfaceT: func() {
   421  			a := interface{}(uint32(0))
   422  			for i := 0; i < mods; i++ {
   423  				a = a.(uint32) + 1
   424  				runtime.Gosched()
   425  			}
   426  		},
   427  	},
   428  	modifier{
   429  		name: "uint64",
   430  		t: func() {
   431  			var u uint64
   432  			for i := 0; i < mods; i++ {
   433  				u++
   434  				runtime.Gosched()
   435  			}
   436  		},
   437  		pointerT: func() {
   438  			a := func() *uint64 { return new(uint64) }()
   439  			for i := 0; i < mods; i++ {
   440  				*a++
   441  				runtime.Gosched()
   442  			}
   443  		},
   444  		arrayT: func() {
   445  			a := [length]uint64{}
   446  			for i := 0; i < mods; i++ {
   447  				for j := 0; j < len(a); j++ {
   448  					a[j]++
   449  					runtime.Gosched()
   450  				}
   451  			}
   452  		},
   453  		sliceT: func() {
   454  			a := make([]uint64, length)
   455  			for i := 0; i < mods; i++ {
   456  				for j := 0; j < len(a); j++ {
   457  					a[j]++
   458  					runtime.Gosched()
   459  				}
   460  			}
   461  		},
   462  		mapT: func() {
   463  			a := make(map[uint64]uint64)
   464  			for i := 0; i < length; i++ {
   465  				a[uint64(i)] = uint64(i)
   466  				runtime.Gosched()
   467  			}
   468  			for i := 0; i < mods; i++ {
   469  				for k, _ := range a {
   470  					a[k]++
   471  				}
   472  				runtime.Gosched()
   473  			}
   474  		},
   475  		mapPointerKeyT: func() {
   476  			a := make(map[*uint64]uint64)
   477  			for i := 0; i < length; i++ {
   478  				a[new(uint64)] = uint64(i)
   479  				runtime.Gosched()
   480  			}
   481  			for i := 0; i < mods; i++ {
   482  				for k, _ := range a {
   483  					a[k]++
   484  					runtime.Gosched()
   485  				}
   486  			}
   487  		},
   488  		chanT: func() {
   489  			a := make(chan uint64)
   490  			for i := 0; i < mods; i++ {
   491  				go func() { a <- uint64(i) }()
   492  				<-a
   493  				runtime.Gosched()
   494  			}
   495  		},
   496  		interfaceT: func() {
   497  			a := interface{}(uint64(0))
   498  			for i := 0; i < mods; i++ {
   499  				a = a.(uint64) + 1
   500  				runtime.Gosched()
   501  			}
   502  		},
   503  	},
   504  	modifier{
   505  		name: "int8",
   506  		t: func() {
   507  			var u int8
   508  			for i := 0; i < mods; i++ {
   509  				u++
   510  				runtime.Gosched()
   511  			}
   512  		},
   513  		pointerT: func() {
   514  			a := func() *int8 { return new(int8) }()
   515  			for i := 0; i < mods; i++ {
   516  				*a++
   517  				runtime.Gosched()
   518  			}
   519  		},
   520  		arrayT: func() {
   521  			a := [length]int8{}
   522  			for i := 0; i < mods; i++ {
   523  				for j := 0; j < len(a); j++ {
   524  					a[j]++
   525  					runtime.Gosched()
   526  				}
   527  			}
   528  		},
   529  		sliceT: func() {
   530  			a := make([]int8, length)
   531  			for i := 0; i < mods; i++ {
   532  				for j := 0; j < len(a); j++ {
   533  					a[j]++
   534  					runtime.Gosched()
   535  				}
   536  			}
   537  		},
   538  		mapT: func() {
   539  			a := make(map[int8]int8)
   540  			for i := 0; i < length; i++ {
   541  				a[int8(i)] = int8(i)
   542  				runtime.Gosched()
   543  			}
   544  			for i := 0; i < mods; i++ {
   545  				for k, _ := range a {
   546  					a[k]++
   547  				}
   548  				runtime.Gosched()
   549  			}
   550  		},
   551  		mapPointerKeyT: func() {
   552  			a := make(map[*int8]int8)
   553  			for i := 0; i < length; i++ {
   554  				a[new(int8)] = int8(i)
   555  				runtime.Gosched()
   556  			}
   557  			for i := 0; i < mods; i++ {
   558  				for k, _ := range a {
   559  					a[k]++
   560  					runtime.Gosched()
   561  				}
   562  			}
   563  		},
   564  		chanT: func() {
   565  			a := make(chan int8)
   566  			for i := 0; i < mods; i++ {
   567  				go func() { a <- int8(i) }()
   568  				<-a
   569  				runtime.Gosched()
   570  			}
   571  		},
   572  		interfaceT: func() {
   573  			a := interface{}(int8(0))
   574  			for i := 0; i < mods; i++ {
   575  				a = a.(int8) + 1
   576  				runtime.Gosched()
   577  			}
   578  		},
   579  	},
   580  	modifier{
   581  		name: "int16",
   582  		t: func() {
   583  			var u int16
   584  			for i := 0; i < mods; i++ {
   585  				u++
   586  				runtime.Gosched()
   587  			}
   588  		},
   589  		pointerT: func() {
   590  			a := func() *int16 { return new(int16) }()
   591  			for i := 0; i < mods; i++ {
   592  				*a++
   593  				runtime.Gosched()
   594  			}
   595  		},
   596  		arrayT: func() {
   597  			a := [length]int16{}
   598  			for i := 0; i < mods; i++ {
   599  				for j := 0; j < len(a); j++ {
   600  					a[j]++
   601  					runtime.Gosched()
   602  				}
   603  			}
   604  		},
   605  		sliceT: func() {
   606  			a := make([]int16, length)
   607  			for i := 0; i < mods; i++ {
   608  				for j := 0; j < len(a); j++ {
   609  					a[j]++
   610  					runtime.Gosched()
   611  				}
   612  			}
   613  		},
   614  		mapT: func() {
   615  			a := make(map[int16]int16)
   616  			for i := 0; i < length; i++ {
   617  				a[int16(i)] = int16(i)
   618  				runtime.Gosched()
   619  			}
   620  			for i := 0; i < mods; i++ {
   621  				for k, _ := range a {
   622  					a[k]++
   623  				}
   624  				runtime.Gosched()
   625  			}
   626  		},
   627  		mapPointerKeyT: func() {
   628  			a := make(map[*int16]int16)
   629  			for i := 0; i < length; i++ {
   630  				a[new(int16)] = int16(i)
   631  				runtime.Gosched()
   632  			}
   633  			for i := 0; i < mods; i++ {
   634  				for k, _ := range a {
   635  					a[k]++
   636  					runtime.Gosched()
   637  				}
   638  			}
   639  		},
   640  		chanT: func() {
   641  			a := make(chan int16)
   642  			for i := 0; i < mods; i++ {
   643  				go func() { a <- int16(i) }()
   644  				<-a
   645  				runtime.Gosched()
   646  			}
   647  		},
   648  		interfaceT: func() {
   649  			a := interface{}(int16(0))
   650  			for i := 0; i < mods; i++ {
   651  				a = a.(int16) + 1
   652  				runtime.Gosched()
   653  			}
   654  		},
   655  	},
   656  	modifier{
   657  		name: "int32",
   658  		t: func() {
   659  			var u int32
   660  			for i := 0; i < mods; i++ {
   661  				u++
   662  				runtime.Gosched()
   663  			}
   664  		},
   665  		pointerT: func() {
   666  			a := func() *int32 { return new(int32) }()
   667  			for i := 0; i < mods; i++ {
   668  				*a++
   669  				runtime.Gosched()
   670  			}
   671  		},
   672  		arrayT: func() {
   673  			a := [length]int32{}
   674  			for i := 0; i < mods; i++ {
   675  				for j := 0; j < len(a); j++ {
   676  					a[j]++
   677  					runtime.Gosched()
   678  				}
   679  			}
   680  		},
   681  		sliceT: func() {
   682  			a := make([]int32, length)
   683  			for i := 0; i < mods; i++ {
   684  				for j := 0; j < len(a); j++ {
   685  					a[j]++
   686  					runtime.Gosched()
   687  				}
   688  			}
   689  		},
   690  		mapT: func() {
   691  			a := make(map[int32]int32)
   692  			for i := 0; i < length; i++ {
   693  				a[int32(i)] = int32(i)
   694  				runtime.Gosched()
   695  			}
   696  			for i := 0; i < mods; i++ {
   697  				for k, _ := range a {
   698  					a[k]++
   699  				}
   700  				runtime.Gosched()
   701  			}
   702  		},
   703  		mapPointerKeyT: func() {
   704  			a := make(map[*int32]int32)
   705  			for i := 0; i < length; i++ {
   706  				a[new(int32)] = int32(i)
   707  				runtime.Gosched()
   708  			}
   709  			for i := 0; i < mods; i++ {
   710  				for k, _ := range a {
   711  					a[k]++
   712  					runtime.Gosched()
   713  				}
   714  			}
   715  		},
   716  		chanT: func() {
   717  			a := make(chan int32)
   718  			for i := 0; i < mods; i++ {
   719  				go func() { a <- int32(i) }()
   720  				<-a
   721  				runtime.Gosched()
   722  			}
   723  		},
   724  		interfaceT: func() {
   725  			a := interface{}(int32(0))
   726  			for i := 0; i < mods; i++ {
   727  				a = a.(int32) + 1
   728  				runtime.Gosched()
   729  			}
   730  		},
   731  	},
   732  	modifier{
   733  		name: "int64",
   734  		t: func() {
   735  			var u int64
   736  			for i := 0; i < mods; i++ {
   737  				u++
   738  				runtime.Gosched()
   739  			}
   740  		},
   741  		pointerT: func() {
   742  			a := func() *int64 { return new(int64) }()
   743  			for i := 0; i < mods; i++ {
   744  				*a++
   745  				runtime.Gosched()
   746  			}
   747  		},
   748  		arrayT: func() {
   749  			a := [length]int64{}
   750  			for i := 0; i < mods; i++ {
   751  				for j := 0; j < len(a); j++ {
   752  					a[j]++
   753  					runtime.Gosched()
   754  				}
   755  			}
   756  		},
   757  		sliceT: func() {
   758  			a := make([]int64, length)
   759  			for i := 0; i < mods; i++ {
   760  				for j := 0; j < len(a); j++ {
   761  					a[j]++
   762  					runtime.Gosched()
   763  				}
   764  			}
   765  		},
   766  		mapT: func() {
   767  			a := make(map[int64]int64)
   768  			for i := 0; i < length; i++ {
   769  				a[int64(i)] = int64(i)
   770  				runtime.Gosched()
   771  			}
   772  			for i := 0; i < mods; i++ {
   773  				for k, _ := range a {
   774  					a[k]++
   775  				}
   776  				runtime.Gosched()
   777  			}
   778  		},
   779  		mapPointerKeyT: func() {
   780  			a := make(map[*int64]int64)
   781  			for i := 0; i < length; i++ {
   782  				a[new(int64)] = int64(i)
   783  				runtime.Gosched()
   784  			}
   785  			for i := 0; i < mods; i++ {
   786  				for k, _ := range a {
   787  					a[k]++
   788  					runtime.Gosched()
   789  				}
   790  			}
   791  		},
   792  		chanT: func() {
   793  			a := make(chan int64)
   794  			for i := 0; i < mods; i++ {
   795  				go func() { a <- int64(i) }()
   796  				<-a
   797  				runtime.Gosched()
   798  			}
   799  		},
   800  		interfaceT: func() {
   801  			a := interface{}(int64(0))
   802  			for i := 0; i < mods; i++ {
   803  				a = a.(int64) + 1
   804  				runtime.Gosched()
   805  			}
   806  		},
   807  	},
   808  	modifier{
   809  		name: "float32",
   810  		t: func() {
   811  			u := float32(1.01)
   812  			for i := 0; i < mods; i++ {
   813  				u *= 1.01
   814  				runtime.Gosched()
   815  			}
   816  		},
   817  		pointerT: func() {
   818  			a := func() *float32 { return new(float32) }()
   819  			*a = 1.01
   820  			for i := 0; i < mods; i++ {
   821  				*a *= 1.01
   822  				runtime.Gosched()
   823  			}
   824  		},
   825  		arrayT: func() {
   826  			a := [length]float32{}
   827  			for i := 0; i < length; i++ {
   828  				a[i] = float32(1.01)
   829  				runtime.Gosched()
   830  			}
   831  			for i := 0; i < mods; i++ {
   832  				for j := 0; j < len(a); j++ {
   833  					a[j] *= 1.01
   834  					runtime.Gosched()
   835  				}
   836  			}
   837  		},
   838  		sliceT: func() {
   839  			a := make([]float32, length)
   840  			for i := 0; i < length; i++ {
   841  				a[i] = float32(1.01)
   842  				runtime.Gosched()
   843  			}
   844  			for i := 0; i < mods; i++ {
   845  				for j := 0; j < len(a); j++ {
   846  					a[j] *= 1.01
   847  					runtime.Gosched()
   848  				}
   849  			}
   850  		},
   851  		mapT: func() {
   852  			a := make(map[float32]float32)
   853  			for i := 0; i < length; i++ {
   854  				a[float32(i)] = float32(i) + 0.01
   855  				runtime.Gosched()
   856  			}
   857  			for i := 0; i < mods; i++ {
   858  				for k, _ := range a {
   859  					a[k] *= 1.01
   860  				}
   861  				runtime.Gosched()
   862  			}
   863  		},
   864  		mapPointerKeyT: func() {
   865  			a := make(map[*float32]float32)
   866  			for i := 0; i < length; i++ {
   867  				a[new(float32)] = float32(i) + 0.01
   868  				runtime.Gosched()
   869  			}
   870  			for i := 0; i < mods; i++ {
   871  				for k, _ := range a {
   872  					a[k] *= 1.01
   873  					runtime.Gosched()
   874  				}
   875  			}
   876  		},
   877  		chanT: func() {
   878  			a := make(chan float32)
   879  			for i := 0; i < mods; i++ {
   880  				go func() { a <- float32(i) }()
   881  				<-a
   882  				runtime.Gosched()
   883  			}
   884  		},
   885  		interfaceT: func() {
   886  			a := interface{}(float32(0))
   887  			for i := 0; i < mods; i++ {
   888  				a = a.(float32) * 1.01
   889  				runtime.Gosched()
   890  			}
   891  		},
   892  	},
   893  	modifier{
   894  		name: "float64",
   895  		t: func() {
   896  			u := float64(1.01)
   897  			for i := 0; i < mods; i++ {
   898  				u *= 1.01
   899  				runtime.Gosched()
   900  			}
   901  		},
   902  		pointerT: func() {
   903  			a := func() *float64 { return new(float64) }()
   904  			*a = 1.01
   905  			for i := 0; i < mods; i++ {
   906  				*a *= 1.01
   907  				runtime.Gosched()
   908  			}
   909  		},
   910  		arrayT: func() {
   911  			a := [length]float64{}
   912  			for i := 0; i < length; i++ {
   913  				a[i] = float64(1.01)
   914  				runtime.Gosched()
   915  			}
   916  			for i := 0; i < mods; i++ {
   917  				for j := 0; j < len(a); j++ {
   918  					a[j] *= 1.01
   919  					runtime.Gosched()
   920  				}
   921  			}
   922  		},
   923  		sliceT: func() {
   924  			a := make([]float64, length)
   925  			for i := 0; i < length; i++ {
   926  				a[i] = float64(1.01)
   927  				runtime.Gosched()
   928  			}
   929  			for i := 0; i < mods; i++ {
   930  				for j := 0; j < len(a); j++ {
   931  					a[j] *= 1.01
   932  					runtime.Gosched()
   933  				}
   934  			}
   935  		},
   936  		mapT: func() {
   937  			a := make(map[float64]float64)
   938  			for i := 0; i < length; i++ {
   939  				a[float64(i)] = float64(i) + 0.01
   940  				runtime.Gosched()
   941  			}
   942  			for i := 0; i < mods; i++ {
   943  				for k, _ := range a {
   944  					a[k] *= 1.01
   945  				}
   946  				runtime.Gosched()
   947  			}
   948  		},
   949  		mapPointerKeyT: func() {
   950  			a := make(map[*float64]float64)
   951  			for i := 0; i < length; i++ {
   952  				a[new(float64)] = float64(i) + 0.01
   953  				runtime.Gosched()
   954  			}
   955  			for i := 0; i < mods; i++ {
   956  				for k, _ := range a {
   957  					a[k] *= 1.01
   958  					runtime.Gosched()
   959  				}
   960  			}
   961  		},
   962  		chanT: func() {
   963  			a := make(chan float64)
   964  			for i := 0; i < mods; i++ {
   965  				go func() { a <- float64(i) }()
   966  				<-a
   967  				runtime.Gosched()
   968  			}
   969  		},
   970  		interfaceT: func() {
   971  			a := interface{}(float64(0))
   972  			for i := 0; i < mods; i++ {
   973  				a = a.(float64) * 1.01
   974  				runtime.Gosched()
   975  			}
   976  		},
   977  	},
   978  	modifier{
   979  		name: "complex64",
   980  		t: func() {
   981  			c := complex64(complex(float32(1.01), float32(1.01)))
   982  			for i := 0; i < mods; i++ {
   983  				c = complex(real(c)*1.01, imag(c)*1.01)
   984  				runtime.Gosched()
   985  			}
   986  		},
   987  		pointerT: func() {
   988  			a := func() *complex64 { return new(complex64) }()
   989  			*a = complex64(complex(float32(1.01), float32(1.01)))
   990  			for i := 0; i < mods; i++ {
   991  				*a *= complex(real(*a)*1.01, imag(*a)*1.01)
   992  				runtime.Gosched()
   993  			}
   994  		},
   995  		arrayT: func() {
   996  			a := [length]complex64{}
   997  			for i := 0; i < length; i++ {
   998  				a[i] = complex64(complex(float32(1.01), float32(1.01)))
   999  				runtime.Gosched()
  1000  			}
  1001  			for i := 0; i < mods; i++ {
  1002  				for j := 0; j < len(a); j++ {
  1003  					a[j] *= complex(real(a[j])*1.01, imag(a[j])*1.01)
  1004  					runtime.Gosched()
  1005  				}
  1006  			}
  1007  		},
  1008  		sliceT: func() {
  1009  			a := make([]complex64, length)
  1010  			for i := 0; i < length; i++ {
  1011  				a[i] = complex64(complex(float32(1.01), float32(1.01)))
  1012  				runtime.Gosched()
  1013  			}
  1014  			for i := 0; i < mods; i++ {
  1015  				for j := 0; j < len(a); j++ {
  1016  					a[j] *= complex(real(a[j])*1.01, imag(a[j])*1.01)
  1017  					runtime.Gosched()
  1018  				}
  1019  			}
  1020  		},
  1021  		mapT: func() {
  1022  			a := make(map[complex64]complex64)
  1023  			for i := 0; i < length; i++ {
  1024  				a[complex64(complex(float32(i), float32(i)))] = complex64(complex(float32(i), float32(i))) + 0.01
  1025  				runtime.Gosched()
  1026  			}
  1027  			for i := 0; i < mods; i++ {
  1028  				for k, _ := range a {
  1029  					a[k] *= complex(real(a[k])*1.01, imag(a[k])*1.01)
  1030  				}
  1031  				runtime.Gosched()
  1032  			}
  1033  		},
  1034  		mapPointerKeyT: func() {
  1035  			a := make(map[*complex64]complex64)
  1036  			for i := 0; i < length; i++ {
  1037  				a[new(complex64)] = complex64(complex(float32(i), float32(i))) + 0.01
  1038  				runtime.Gosched()
  1039  			}
  1040  			for i := 0; i < mods; i++ {
  1041  				for k, _ := range a {
  1042  					a[k] *= complex(real(a[k])*1.01, imag(a[k])*1.01)
  1043  					runtime.Gosched()
  1044  				}
  1045  			}
  1046  		},
  1047  		chanT: func() {
  1048  			a := make(chan complex64)
  1049  			for i := 0; i < mods; i++ {
  1050  				go func() { a <- complex64(complex(float32(i), float32(i))) }()
  1051  				<-a
  1052  				runtime.Gosched()
  1053  			}
  1054  		},
  1055  		interfaceT: func() {
  1056  			a := interface{}(complex64(complex(float32(1.01), float32(1.01))))
  1057  			for i := 0; i < mods; i++ {
  1058  				a = a.(complex64) * complex(real(a.(complex64))*1.01, imag(a.(complex64))*1.01)
  1059  				runtime.Gosched()
  1060  			}
  1061  		},
  1062  	},
  1063  	modifier{
  1064  		name: "complex128",
  1065  		t: func() {
  1066  			c := complex128(complex(float64(1.01), float64(1.01)))
  1067  			for i := 0; i < mods; i++ {
  1068  				c = complex(real(c)*1.01, imag(c)*1.01)
  1069  				runtime.Gosched()
  1070  			}
  1071  		},
  1072  		pointerT: func() {
  1073  			a := func() *complex128 { return new(complex128) }()
  1074  			*a = complex128(complex(float64(1.01), float64(1.01)))
  1075  			for i := 0; i < mods; i++ {
  1076  				*a *= complex(real(*a)*1.01, imag(*a)*1.01)
  1077  				runtime.Gosched()
  1078  			}
  1079  		},
  1080  		arrayT: func() {
  1081  			a := [length]complex128{}
  1082  			for i := 0; i < length; i++ {
  1083  				a[i] = complex128(complex(float64(1.01), float64(1.01)))
  1084  				runtime.Gosched()
  1085  			}
  1086  			for i := 0; i < mods; i++ {
  1087  				for j := 0; j < len(a); j++ {
  1088  					a[j] *= complex(real(a[j])*1.01, imag(a[j])*1.01)
  1089  					runtime.Gosched()
  1090  				}
  1091  			}
  1092  		},
  1093  		sliceT: func() {
  1094  			a := make([]complex128, length)
  1095  			for i := 0; i < length; i++ {
  1096  				a[i] = complex128(complex(float64(1.01), float64(1.01)))
  1097  				runtime.Gosched()
  1098  			}
  1099  			for i := 0; i < mods; i++ {
  1100  				for j := 0; j < len(a); j++ {
  1101  					a[j] *= complex(real(a[j])*1.01, imag(a[j])*1.01)
  1102  					runtime.Gosched()
  1103  				}
  1104  			}
  1105  		},
  1106  		mapT: func() {
  1107  			a := make(map[complex128]complex128)
  1108  			for i := 0; i < length; i++ {
  1109  				a[complex128(complex(float64(i), float64(i)))] = complex128(complex(float64(i), float64(i))) + 0.01
  1110  				runtime.Gosched()
  1111  			}
  1112  			for i := 0; i < mods; i++ {
  1113  				for k, _ := range a {
  1114  					a[k] *= complex(real(a[k])*1.01, imag(a[k])*1.01)
  1115  				}
  1116  				runtime.Gosched()
  1117  			}
  1118  		},
  1119  		mapPointerKeyT: func() {
  1120  			a := make(map[*complex128]complex128)
  1121  			for i := 0; i < length; i++ {
  1122  				a[new(complex128)] = complex128(complex(float64(i), float64(i))) + 0.01
  1123  				runtime.Gosched()
  1124  			}
  1125  			for i := 0; i < mods; i++ {
  1126  				for k, _ := range a {
  1127  					a[k] *= complex(real(a[k])*1.01, imag(a[k])*1.01)
  1128  					runtime.Gosched()
  1129  				}
  1130  			}
  1131  		},
  1132  		chanT: func() {
  1133  			a := make(chan complex128)
  1134  			for i := 0; i < mods; i++ {
  1135  				go func() { a <- complex128(complex(float64(i), float64(i))) }()
  1136  				<-a
  1137  				runtime.Gosched()
  1138  			}
  1139  		},
  1140  		interfaceT: func() {
  1141  			a := interface{}(complex128(complex(float64(1.01), float64(1.01))))
  1142  			for i := 0; i < mods; i++ {
  1143  				a = a.(complex128) * complex(real(a.(complex128))*1.01, imag(a.(complex128))*1.01)
  1144  				runtime.Gosched()
  1145  			}
  1146  		},
  1147  	},
  1148  	modifier{
  1149  		name: "byte",
  1150  		t: func() {
  1151  			var a byte
  1152  			for i := 0; i < mods; i++ {
  1153  				a++
  1154  				runtime.Gosched()
  1155  			}
  1156  		},
  1157  		pointerT: func() {
  1158  			a := func() *byte { return new(byte) }()
  1159  			for i := 0; i < mods; i++ {
  1160  				*a++
  1161  				runtime.Gosched()
  1162  			}
  1163  		},
  1164  		arrayT: func() {
  1165  			a := [length]byte{}
  1166  			for i := 0; i < mods; i++ {
  1167  				for j := 0; j < len(a); j++ {
  1168  					a[j]++
  1169  					runtime.Gosched()
  1170  				}
  1171  			}
  1172  		},
  1173  		sliceT: func() {
  1174  			a := make([]byte, length)
  1175  			for i := 0; i < mods; i++ {
  1176  				for j := 0; j < len(a); j++ {
  1177  					a[j]++
  1178  					runtime.Gosched()
  1179  				}
  1180  			}
  1181  		},
  1182  		mapT: func() {
  1183  			a := make(map[byte]byte)
  1184  			for i := 0; i < length; i++ {
  1185  				a[byte(i)] = byte(i)
  1186  				runtime.Gosched()
  1187  			}
  1188  			for i := 0; i < mods; i++ {
  1189  				for k, _ := range a {
  1190  					a[k]++
  1191  				}
  1192  				runtime.Gosched()
  1193  			}
  1194  		},
  1195  		mapPointerKeyT: func() {
  1196  			a := make(map[*byte]byte)
  1197  			for i := 0; i < length; i++ {
  1198  				a[new(byte)] = byte(i)
  1199  				runtime.Gosched()
  1200  			}
  1201  			for i := 0; i < mods; i++ {
  1202  				for k, _ := range a {
  1203  					a[k]++
  1204  					runtime.Gosched()
  1205  				}
  1206  			}
  1207  		},
  1208  		chanT: func() {
  1209  			a := make(chan byte)
  1210  			for i := 0; i < mods; i++ {
  1211  				go func() { a <- byte(i) }()
  1212  				<-a
  1213  				runtime.Gosched()
  1214  			}
  1215  		},
  1216  		interfaceT: func() {
  1217  			a := interface{}(byte(0))
  1218  			for i := 0; i < mods; i++ {
  1219  				a = a.(byte) + 1
  1220  				runtime.Gosched()
  1221  			}
  1222  		},
  1223  	},
  1224  	modifier{
  1225  		name: "rune",
  1226  		t: func() {
  1227  			var a rune
  1228  			for i := 0; i < mods; i++ {
  1229  				a++
  1230  				runtime.Gosched()
  1231  			}
  1232  		},
  1233  		pointerT: func() {
  1234  			a := func() *rune { return new(rune) }()
  1235  			for i := 0; i < mods; i++ {
  1236  				*a++
  1237  				runtime.Gosched()
  1238  			}
  1239  		},
  1240  		arrayT: func() {
  1241  			a := [length]rune{}
  1242  			for i := 0; i < mods; i++ {
  1243  				for j := 0; j < len(a); j++ {
  1244  					a[j]++
  1245  					runtime.Gosched()
  1246  				}
  1247  			}
  1248  		},
  1249  		sliceT: func() {
  1250  			a := make([]rune, length)
  1251  			for i := 0; i < mods; i++ {
  1252  				for j := 0; j < len(a); j++ {
  1253  					a[j]++
  1254  					runtime.Gosched()
  1255  				}
  1256  			}
  1257  		},
  1258  		mapT: func() {
  1259  			a := make(map[rune]rune)
  1260  			for i := 0; i < length; i++ {
  1261  				a[rune(i)] = rune(i)
  1262  				runtime.Gosched()
  1263  			}
  1264  			for i := 0; i < mods; i++ {
  1265  				for k, _ := range a {
  1266  					a[k]++
  1267  				}
  1268  				runtime.Gosched()
  1269  			}
  1270  		},
  1271  		mapPointerKeyT: func() {
  1272  			a := make(map[*rune]rune)
  1273  			for i := 0; i < length; i++ {
  1274  				a[new(rune)] = rune(i)
  1275  				runtime.Gosched()
  1276  			}
  1277  			for i := 0; i < mods; i++ {
  1278  				for k, _ := range a {
  1279  					a[k]++
  1280  					runtime.Gosched()
  1281  				}
  1282  			}
  1283  		},
  1284  		chanT: func() {
  1285  			a := make(chan rune)
  1286  			for i := 0; i < mods; i++ {
  1287  				go func() { a <- rune(i) }()
  1288  				<-a
  1289  				runtime.Gosched()
  1290  			}
  1291  		},
  1292  		interfaceT: func() {
  1293  			a := interface{}(rune(0))
  1294  			for i := 0; i < mods; i++ {
  1295  				a = a.(rune) + 1
  1296  				runtime.Gosched()
  1297  			}
  1298  		},
  1299  	},
  1300  	modifier{
  1301  		name: "uint",
  1302  		t: func() {
  1303  			var a uint
  1304  			for i := 0; i < mods; i++ {
  1305  				a++
  1306  				runtime.Gosched()
  1307  			}
  1308  		},
  1309  		pointerT: func() {
  1310  			a := func() *uint { return new(uint) }()
  1311  			for i := 0; i < mods; i++ {
  1312  				*a++
  1313  				runtime.Gosched()
  1314  			}
  1315  		},
  1316  		arrayT: func() {
  1317  			a := [length]uint{}
  1318  			for i := 0; i < mods; i++ {
  1319  				for j := 0; j < len(a); j++ {
  1320  					a[j]++
  1321  					runtime.Gosched()
  1322  				}
  1323  			}
  1324  		},
  1325  		sliceT: func() {
  1326  			a := make([]uint, length)
  1327  			for i := 0; i < mods; i++ {
  1328  				for j := 0; j < len(a); j++ {
  1329  					a[j]++
  1330  					runtime.Gosched()
  1331  				}
  1332  			}
  1333  		},
  1334  		mapT: func() {
  1335  			a := make(map[uint]uint)
  1336  			for i := 0; i < length; i++ {
  1337  				a[uint(i)] = uint(i)
  1338  				runtime.Gosched()
  1339  			}
  1340  			for i := 0; i < mods; i++ {
  1341  				for k, _ := range a {
  1342  					a[k]++
  1343  				}
  1344  				runtime.Gosched()
  1345  			}
  1346  		},
  1347  		mapPointerKeyT: func() {
  1348  			a := make(map[*uint]uint)
  1349  			for i := 0; i < length; i++ {
  1350  				a[new(uint)] = uint(i)
  1351  				runtime.Gosched()
  1352  			}
  1353  			for i := 0; i < mods; i++ {
  1354  				for k, _ := range a {
  1355  					a[k]++
  1356  					runtime.Gosched()
  1357  				}
  1358  			}
  1359  		},
  1360  		chanT: func() {
  1361  			a := make(chan uint)
  1362  			for i := 0; i < mods; i++ {
  1363  				go func() { a <- uint(i) }()
  1364  				<-a
  1365  				runtime.Gosched()
  1366  			}
  1367  		},
  1368  		interfaceT: func() {
  1369  			a := interface{}(uint(0))
  1370  			for i := 0; i < mods; i++ {
  1371  				a = a.(uint) + 1
  1372  				runtime.Gosched()
  1373  			}
  1374  		},
  1375  	},
  1376  	modifier{
  1377  		name: "int",
  1378  		t: func() {
  1379  			var a int
  1380  			for i := 0; i < mods; i++ {
  1381  				a++
  1382  				runtime.Gosched()
  1383  			}
  1384  		},
  1385  		pointerT: func() {
  1386  			a := func() *int { return new(int) }()
  1387  			for i := 0; i < mods; i++ {
  1388  				*a++
  1389  				runtime.Gosched()
  1390  			}
  1391  		},
  1392  		arrayT: func() {
  1393  			a := [length]int{}
  1394  			for i := 0; i < mods; i++ {
  1395  				for j := 0; j < len(a); j++ {
  1396  					a[j]++
  1397  					runtime.Gosched()
  1398  				}
  1399  			}
  1400  		},
  1401  		sliceT: func() {
  1402  			a := make([]int, length)
  1403  			for i := 0; i < mods; i++ {
  1404  				for j := 0; j < len(a); j++ {
  1405  					a[j]++
  1406  					runtime.Gosched()
  1407  				}
  1408  			}
  1409  		},
  1410  		mapT: func() {
  1411  			a := make(map[int]int)
  1412  			for i := 0; i < length; i++ {
  1413  				a[int(i)] = int(i)
  1414  				runtime.Gosched()
  1415  			}
  1416  			for i := 0; i < mods; i++ {
  1417  				for k, _ := range a {
  1418  					a[k]++
  1419  				}
  1420  				runtime.Gosched()
  1421  			}
  1422  		},
  1423  		mapPointerKeyT: func() {
  1424  			a := make(map[*int]int)
  1425  			for i := 0; i < length; i++ {
  1426  				a[new(int)] = int(i)
  1427  				runtime.Gosched()
  1428  			}
  1429  			for i := 0; i < mods; i++ {
  1430  				for k, _ := range a {
  1431  					a[k]++
  1432  					runtime.Gosched()
  1433  				}
  1434  			}
  1435  		},
  1436  		chanT: func() {
  1437  			a := make(chan int)
  1438  			for i := 0; i < mods; i++ {
  1439  				go func() { a <- int(i) }()
  1440  				<-a
  1441  				runtime.Gosched()
  1442  			}
  1443  		},
  1444  		interfaceT: func() {
  1445  			a := interface{}(int(0))
  1446  			for i := 0; i < mods; i++ {
  1447  				a = a.(int) + 1
  1448  				runtime.Gosched()
  1449  			}
  1450  		},
  1451  	},
  1452  	modifier{
  1453  		name: "uintptr",
  1454  		t: func() {
  1455  			var a uintptr
  1456  			for i := 0; i < mods; i++ {
  1457  				a++
  1458  				runtime.Gosched()
  1459  			}
  1460  		},
  1461  		pointerT: func() {
  1462  			a := func() *uintptr { return new(uintptr) }()
  1463  			for i := 0; i < mods; i++ {
  1464  				*a++
  1465  				runtime.Gosched()
  1466  			}
  1467  		},
  1468  		arrayT: func() {
  1469  			a := [length]uintptr{}
  1470  			for i := 0; i < mods; i++ {
  1471  				for j := 0; j < len(a); j++ {
  1472  					a[j]++
  1473  					runtime.Gosched()
  1474  				}
  1475  			}
  1476  		},
  1477  		sliceT: func() {
  1478  			a := make([]uintptr, length)
  1479  			for i := 0; i < mods; i++ {
  1480  				for j := 0; j < len(a); j++ {
  1481  					a[j]++
  1482  					runtime.Gosched()
  1483  				}
  1484  			}
  1485  		},
  1486  		mapT: func() {
  1487  			a := make(map[uintptr]uintptr)
  1488  			for i := 0; i < length; i++ {
  1489  				a[uintptr(i)] = uintptr(i)
  1490  				runtime.Gosched()
  1491  			}
  1492  			for i := 0; i < mods; i++ {
  1493  				for k, _ := range a {
  1494  					a[k]++
  1495  				}
  1496  				runtime.Gosched()
  1497  			}
  1498  		},
  1499  		mapPointerKeyT: func() {
  1500  			a := make(map[*uintptr]uintptr)
  1501  			for i := 0; i < length; i++ {
  1502  				a[new(uintptr)] = uintptr(i)
  1503  				runtime.Gosched()
  1504  			}
  1505  			for i := 0; i < mods; i++ {
  1506  				for k, _ := range a {
  1507  					a[k]++
  1508  					runtime.Gosched()
  1509  				}
  1510  			}
  1511  		},
  1512  		chanT: func() {
  1513  			a := make(chan uintptr)
  1514  			for i := 0; i < mods; i++ {
  1515  				go func() { a <- uintptr(i) }()
  1516  				<-a
  1517  				runtime.Gosched()
  1518  			}
  1519  		},
  1520  		interfaceT: func() {
  1521  			a := interface{}(uintptr(0))
  1522  			for i := 0; i < mods; i++ {
  1523  				a = a.(uintptr) + 1
  1524  				runtime.Gosched()
  1525  			}
  1526  		},
  1527  	},
  1528  	modifier{
  1529  		name: "string",
  1530  		t: func() {
  1531  			var s string
  1532  			f := func(a string) string { return a }
  1533  			for i := 0; i < mods; i++ {
  1534  				s = str(i)
  1535  				s = f(s)
  1536  			}
  1537  		},
  1538  		pointerT: func() {
  1539  			a := func() *string { return new(string) }()
  1540  			for i := 0; i < mods; i++ {
  1541  				*a = str(i)
  1542  				runtime.Gosched()
  1543  			}
  1544  		},
  1545  		arrayT: func() {
  1546  			a := [length]string{}
  1547  			for i := 0; i < mods; i++ {
  1548  				for j := 0; j < len(a); j++ {
  1549  					a[j] = str(i)
  1550  					runtime.Gosched()
  1551  				}
  1552  			}
  1553  		},
  1554  		sliceT: func() {
  1555  			a := make([]string, length)
  1556  			for i := 0; i < mods; i++ {
  1557  				for j := 0; j < len(a); j++ {
  1558  					a[j] = str(i)
  1559  					runtime.Gosched()
  1560  				}
  1561  			}
  1562  		},
  1563  		mapT: func() {
  1564  			a := make(map[string]string)
  1565  			for i := 0; i < length; i++ {
  1566  				a[string(i)] = str(i)
  1567  				runtime.Gosched()
  1568  			}
  1569  			for i := 0; i < mods; i++ {
  1570  				for k, _ := range a {
  1571  					a[k] = str(i)
  1572  				}
  1573  				runtime.Gosched()
  1574  			}
  1575  		},
  1576  		mapPointerKeyT: func() {
  1577  			a := make(map[*string]string)
  1578  			for i := 0; i < length; i++ {
  1579  				a[new(string)] = str(i)
  1580  				runtime.Gosched()
  1581  			}
  1582  			for i := 0; i < mods; i++ {
  1583  				for k, _ := range a {
  1584  					a[k] = str(i)
  1585  					runtime.Gosched()
  1586  				}
  1587  			}
  1588  		},
  1589  		chanT: func() {
  1590  			a := make(chan string)
  1591  			for i := 0; i < mods; i++ {
  1592  				go func() { a <- str(i) }()
  1593  				<-a
  1594  				runtime.Gosched()
  1595  			}
  1596  		},
  1597  		interfaceT: func() {
  1598  			a := interface{}(str(0))
  1599  			f := func(a string) string { return a }
  1600  			for i := 0; i < mods; i++ {
  1601  				a = str(i)
  1602  				a = f(a.(string))
  1603  				runtime.Gosched()
  1604  			}
  1605  		},
  1606  	},
  1607  	modifier{
  1608  		name: "structT",
  1609  		t: func() {
  1610  			s := newStructT()
  1611  			for i := 0; i < mods; i++ {
  1612  				s.u8++
  1613  				s.u16++
  1614  				s.u32++
  1615  				s.u64++
  1616  				s.i8++
  1617  				s.i16++
  1618  				s.i32++
  1619  				s.i64++
  1620  				s.f32 *= 1.01
  1621  				s.f64 *= 1.01
  1622  				s.c64 = complex(real(s.c64)*1.01, imag(s.c64)*1.01)
  1623  				s.c128 = complex(real(s.c128)*1.01, imag(s.c128)*1.01)
  1624  				s.b++
  1625  				s.r++
  1626  				s.u++
  1627  				s.in++
  1628  				s.uip++
  1629  				s.s = str(i)
  1630  				runtime.Gosched()
  1631  			}
  1632  		},
  1633  		pointerT: func() {
  1634  			s := func() *structT {
  1635  				t := newStructT()
  1636  				return &t
  1637  			}()
  1638  			for i := 0; i < mods; i++ {
  1639  				s.u8++
  1640  				s.u16++
  1641  				s.u32++
  1642  				s.u64++
  1643  				s.i8++
  1644  				s.i16++
  1645  				s.i32++
  1646  				s.i64++
  1647  				s.f32 *= 1.01
  1648  				s.f64 *= 1.01
  1649  				s.c64 = complex(real(s.c64)*1.01, imag(s.c64)*1.01)
  1650  				s.c128 = complex(real(s.c128)*1.01, imag(s.c128)*1.01)
  1651  				s.b++
  1652  				s.r++
  1653  				s.u++
  1654  				s.in++
  1655  				s.uip++
  1656  				s.s = str(i)
  1657  				runtime.Gosched()
  1658  			}
  1659  		},
  1660  		arrayT: func() {
  1661  			a := [length]structT{}
  1662  			for i := 0; i < len(a); i++ {
  1663  				a[i] = newStructT()
  1664  			}
  1665  			for i := 0; i < mods; i++ {
  1666  				for j := 0; j < len(a); j++ {
  1667  					a[j].u8++
  1668  					a[j].u16++
  1669  					a[j].u32++
  1670  					a[j].u64++
  1671  					a[j].i8++
  1672  					a[j].i16++
  1673  					a[j].i32++
  1674  					a[j].i64++
  1675  					a[j].f32 *= 1.01
  1676  					a[j].f64 *= 1.01
  1677  					a[j].c64 = complex(real(a[j].c64)*1.01, imag(a[j].c64)*1.01)
  1678  					a[j].c128 = complex(real(a[j].c128)*1.01, imag(a[j].c128)*1.01)
  1679  					a[j].b++
  1680  					a[j].r++
  1681  					a[j].u++
  1682  					a[j].in++
  1683  					a[j].uip++
  1684  					a[j].s = str(i)
  1685  					runtime.Gosched()
  1686  				}
  1687  			}
  1688  		},
  1689  		sliceT: func() {
  1690  			a := make([]structT, length)
  1691  			for i := 0; i < len(a); i++ {
  1692  				a[i] = newStructT()
  1693  			}
  1694  			for i := 0; i < mods; i++ {
  1695  				for j := 0; j < len(a); j++ {
  1696  					a[j].u8++
  1697  					a[j].u16++
  1698  					a[j].u32++
  1699  					a[j].u64++
  1700  					a[j].i8++
  1701  					a[j].i16++
  1702  					a[j].i32++
  1703  					a[j].i64++
  1704  					a[j].f32 *= 1.01
  1705  					a[j].f64 *= 1.01
  1706  					a[j].c64 = complex(real(a[j].c64)*1.01, imag(a[j].c64)*1.01)
  1707  					a[j].c128 = complex(real(a[j].c128)*1.01, imag(a[j].c128)*1.01)
  1708  					a[j].b++
  1709  					a[j].r++
  1710  					a[j].u++
  1711  					a[j].in++
  1712  					a[j].uip++
  1713  					a[j].s = str(i)
  1714  					runtime.Gosched()
  1715  				}
  1716  			}
  1717  		},
  1718  		mapT: func() {
  1719  			a := make(map[structT]structT)
  1720  			for i := 0; i < length; i++ {
  1721  				m := newStructT()
  1722  				m.in = i
  1723  				a[m] = newStructT()
  1724  				runtime.Gosched()
  1725  			}
  1726  			for i := 0; i < mods; i++ {
  1727  				for j, _ := range a {
  1728  					m := a[j]
  1729  					m.u8++
  1730  					m.u16++
  1731  					m.u32++
  1732  					m.u64++
  1733  					m.i8++
  1734  					m.i16++
  1735  					m.i32++
  1736  					m.i64++
  1737  					m.f32 *= 1.01
  1738  					m.f64 *= 1.01
  1739  					m.c64 = complex(real(a[j].c64)*1.01, imag(a[j].c64)*1.01)
  1740  					m.c128 = complex(real(a[j].c128)*1.01, imag(a[j].c128)*1.01)
  1741  					m.b++
  1742  					m.r++
  1743  					m.u++
  1744  					m.in++
  1745  					m.uip++
  1746  					m.s = str(i)
  1747  					a[j] = m
  1748  					runtime.Gosched()
  1749  				}
  1750  				runtime.Gosched()
  1751  			}
  1752  		},
  1753  		mapPointerKeyT: func() {
  1754  			a := make(map[*structT]structT)
  1755  			f := func() *structT {
  1756  				m := newStructT()
  1757  				return &m
  1758  			}
  1759  			for i := 0; i < length; i++ {
  1760  				m := f()
  1761  				m.in = i
  1762  				a[m] = newStructT()
  1763  				runtime.Gosched()
  1764  			}
  1765  			for i := 0; i < mods; i++ {
  1766  				for j, _ := range a {
  1767  					m := a[j]
  1768  					m.u8++
  1769  					m.u16++
  1770  					m.u32++
  1771  					m.u64++
  1772  					m.i8++
  1773  					m.i16++
  1774  					m.i32++
  1775  					m.i64++
  1776  					m.f32 *= 1.01
  1777  					m.f64 *= 1.01
  1778  					m.c64 = complex(real(a[j].c64)*1.01, imag(a[j].c64)*1.01)
  1779  					m.c128 = complex(real(a[j].c128)*1.01, imag(a[j].c128)*1.01)
  1780  					m.b++
  1781  					m.r++
  1782  					m.u++
  1783  					m.in++
  1784  					m.uip++
  1785  					m.s = str(i)
  1786  					a[j] = m
  1787  					runtime.Gosched()
  1788  				}
  1789  				runtime.Gosched()
  1790  			}
  1791  		},
  1792  		chanT: func() {
  1793  			a := make(chan structT)
  1794  			for i := 0; i < mods; i++ {
  1795  				go func() { a <- newStructT() }()
  1796  				<-a
  1797  				runtime.Gosched()
  1798  			}
  1799  		},
  1800  		interfaceT: func() {
  1801  			a := interface{}(newStructT())
  1802  			for i := 0; i < mods; i++ {
  1803  				a = a.(structT)
  1804  				runtime.Gosched()
  1805  			}
  1806  		},
  1807  	},
  1808  }
  1809  
  1810  type structT struct {
  1811  	u8   uint8
  1812  	u16  uint16
  1813  	u32  uint32
  1814  	u64  uint64
  1815  	i8   int8
  1816  	i16  int16
  1817  	i32  int32
  1818  	i64  int64
  1819  	f32  float32
  1820  	f64  float64
  1821  	c64  complex64
  1822  	c128 complex128
  1823  	b    byte
  1824  	r    rune
  1825  	u    uint
  1826  	in   int
  1827  	uip  uintptr
  1828  	s    string
  1829  }
  1830  
  1831  func newStructT() structT {
  1832  	return structT{
  1833  		f32:  1.01,
  1834  		f64:  1.01,
  1835  		c64:  complex(float32(1.01), float32(1.01)),
  1836  		c128: complex(float64(1.01), float64(1.01)),
  1837  	}
  1838  }
  1839  
  1840  func str(in int) string {
  1841  	switch in % 3 {
  1842  	case 0:
  1843  		return "Hello"
  1844  	case 1:
  1845  		return "world"
  1846  	case 2:
  1847  		return "!"
  1848  	}
  1849  	return "?"
  1850  }
  1851  

View as plain text