cockroach2448.go

     1  // Copyright 2025 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a MIT
     3  // license that can be found in the LICENSE file.
     4  
     5  package main
     6  
     7  import (
     8  	"os"
     9  	"runtime"
    10  	"runtime/pprof"
    11  	"time"
    12  )
    13  
    14  func init() {
    15  	register("Cockroach2448", Cockroach2448)
    16  }
    17  
    18  type Stopper_cockroach2448 struct {
    19  	Done chan bool
    20  }
    21  
    22  func (s *Stopper_cockroach2448) ShouldStop() <-chan bool {
    23  	return s.Done
    24  }
    25  
    26  type EventMembershipChangeCommitted_cockroach2448 struct {
    27  	Callback func()
    28  }
    29  
    30  type MultiRaft_cockroach2448 struct {
    31  	stopper      *Stopper_cockroach2448
    32  	Events       chan interface{}
    33  	callbackChan chan func()
    34  }
    35  
    36  // sendEvent can be invoked many times
    37  func (m *MultiRaft_cockroach2448) sendEvent(event interface{}) {
    38  	select {
    39  	case m.Events <- event: // Waiting for events consumption
    40  	case <-m.stopper.ShouldStop():
    41  	}
    42  }
    43  
    44  type state_cockroach2448 struct {
    45  	*MultiRaft_cockroach2448
    46  }
    47  
    48  func (s *state_cockroach2448) start() {
    49  	for {
    50  		select {
    51  		case <-s.stopper.ShouldStop():
    52  			return
    53  		case cb := <-s.callbackChan:
    54  			cb()
    55  		default:
    56  			s.handleWriteResponse()
    57  			time.Sleep(100 * time.Microsecond)
    58  		}
    59  	}
    60  }
    61  
    62  func (s *state_cockroach2448) handleWriteResponse() {
    63  	s.sendEvent(&EventMembershipChangeCommitted_cockroach2448{
    64  		Callback: func() {
    65  			select {
    66  			case s.callbackChan <- func() { // Waiting for callbackChan consumption
    67  				time.Sleep(time.Nanosecond)
    68  			}:
    69  			case <-s.stopper.ShouldStop():
    70  			}
    71  		},
    72  	})
    73  }
    74  
    75  type Store_cockroach2448 struct {
    76  	multiraft *MultiRaft_cockroach2448
    77  }
    78  
    79  func (s *Store_cockroach2448) processRaft() {
    80  	for {
    81  		select {
    82  		case e := <-s.multiraft.Events:
    83  			switch e := e.(type) {
    84  			case *EventMembershipChangeCommitted_cockroach2448:
    85  				callback := e.Callback
    86  				runtime.Gosched()
    87  				if callback != nil {
    88  					callback() // Waiting for callbackChan consumption
    89  				}
    90  			}
    91  		case <-s.multiraft.stopper.ShouldStop():
    92  			return
    93  		}
    94  	}
    95  }
    96  
    97  func NewStoreAndState_cockroach2448() (*Store_cockroach2448, *state_cockroach2448) {
    98  	stopper := &Stopper_cockroach2448{
    99  		Done: make(chan bool),
   100  	}
   101  	mltrft := &MultiRaft_cockroach2448{
   102  		stopper:      stopper,
   103  		Events:       make(chan interface{}),
   104  		callbackChan: make(chan func()),
   105  	}
   106  	st := &state_cockroach2448{mltrft}
   107  	s := &Store_cockroach2448{mltrft}
   108  	return s, st
   109  }
   110  
   111  func Cockroach2448() {
   112  	prof := pprof.Lookup("goroutineleak")
   113  	defer func() {
   114  		time.Sleep(100 * time.Millisecond)
   115  		prof.WriteTo(os.Stdout, 2)
   116  	}()
   117  	for i := 0; i < 1000; i++ {
   118  		go func() {
   119  			s, st := NewStoreAndState_cockroach2448()
   120  			go s.processRaft() // G1
   121  			go st.start()      // G2
   122  		}()
   123  	}
   124  }
   125  
   126
View as plain text