func findInRing(in *ring.Ring, f func(r interface{}) bool) *ring.Ring {
if f(in.Value) {
return in
}
for p := in.Next(); p != in; p = p.Next() {
if f(p.Value) {
return p
}
}
return nil
}
func containsTask(finishedTasks *ring.Ring, taskId string) bool {
for i := 0; i < defaultFinishedTasksSize; i++ {
value := finishedTasks.Next().Value
if value == nil {
continue
}
if value.(string) == taskId {
return true
}
}
return false
}
func RingToStringInt64(r *ring.Ring, delim string, delta bool) string {
bb := new(bytes.Buffer)
prev := r.Value.(int64)
r = r.Next()
for i := 1; i < r.Len(); i++ {
if delta {
if r.Value.(int64) == int64(0) {
bb.WriteString(fmt.Sprintf("0%s", delim))
} else {
d := r.Value.(int64) - prev
bb.WriteString(fmt.Sprintf("%d%s", d, delim))
}
prev = r.Value.(int64)
} else {
bb.WriteString(fmt.Sprintf("%d%s", r.Value.(int64), delim))
}
r = r.Next()
}
return strings.TrimSuffix(bb.String(), delim)
}
func generadorTPS(nroMaxPeticiones uint64, lambda float64, q chan<- []byte, contadorPeticiones *uint64, forever bool, tiras *ring.Ring, procesoLlegada string) {
if procesoLlegada == "M" {
for ; forever || *contadorPeticiones < nroMaxPeticiones; *contadorPeticiones++ {
time.Sleep(time.Duration(int64(1000000000.0 * rand.ExpFloat64() / lambda)))
q <- (tiras.Value.([]byte))
tiras = tiras.Next()
}
} else { /* procesoLlegada == "D" */
// Utilizo un Ticker como referencia.
// Lo encapsulo en generadorTPS porque el Ticker utiliza un canal sincrono.
// aunque el ticker nunca se bloquea
ticker := time.NewTicker(time.Duration(int64(1000000000.0 / lambda)))
for ; forever || *contadorPeticiones < nroMaxPeticiones; *contadorPeticiones++ {
<-ticker.C
q <- (tiras.Value.([]byte))
tiras = tiras.Next()
}
ticker.Stop()
}
close(q)
}
func main() {
var n, m int
f, _ := os.Create("yes.pprof")
pprof.StartCPUProfile(f)
defer pprof.StopCPUProfile()
fmt.Scan(&n)
fmt.Scan(&m)
bucket2number := make(map[int]*ring.Ring)
number2bucket := map[int]int{0: 0, n - 1: n - 1}
bucketlen := map[int]int{0: 1, n - 1: 1}
bucket2number[0] = ring.New(1)
bucket2number[0].Value = 0
bucket2number[n-1] = ring.New(1)
bucket2number[n-1].Value = n - 1
var a, b int
var la, lb *ring.Ring
var debug = false
for i := 0; i <= m; i++ {
fmt.Scan(&a, &b)
ba, ok := number2bucket[a]
if !ok {
number2bucket[a] = a
bucketlen[a] = 1
ba = a
la = ring.New(1)
la.Value = a
bucket2number[ba] = la
} else {
la = bucket2number[ba]
}
bb, ok := number2bucket[b]
if !ok {
number2bucket[b] = b
bucketlen[b] = 1
bb = b
lb = ring.New(1)
lb.Value = b
bucket2number[bb] = lb
} else {
lb = bucket2number[bb]
}
if ba != bb {
// Not connected yet
if bucketlen[ba] < bucketlen[bb] {
la, lb = lb, la
ba, bb = bb, ba
}
for j := 0; j < bucketlen[bb]; j++ {
number2bucket[lb.Value.(int)] = ba
lb = lb.Next()
}
la.Link(lb)
bucketlen[ba] += bucketlen[bb]
delete(bucket2number, bb)
if number2bucket[0] == number2bucket[n-1] {
fmt.Printf("Connected at %d\n", i)
return
}
}
if debug {
fmt.Printf("%d -> %d\n", a, b)
fmt.Print("Bucket2Number\n")
for k, v := range bucket2number {
fmt.Print(k)
v.Do(
func(x interface{}) {
fmt.Printf(" %d", x.(int))
})
fmt.Println()
}
fmt.Print("Number2Bucket\n")
for k, v := range number2bucket {
fmt.Printf("%d: %d\n", k, v)
}
}
}
fmt.Println("Not connected")
}
func rollup(r *ring.Ring) *ring.Ring {
n := r.Next()
return seed(n)
}