/**
   * Multiple threads using same array of counters successfully update a number of times equal to
   * total count
   */
  public void testCountingInMultipleThreads() throws InterruptedException {
    final AtomicDoubleArray aa = new AtomicDoubleArray(SIZE);
    for (int i = 0; i < SIZE; i++) {
      aa.set(i, (double) COUNTDOWN);
    }
    Counter c1 = new Counter(aa);
    Counter c2 = new Counter(aa);

			}
			wroteNext = true
		} else {
			c.next.Store(next)
		}
		if f.counters.CompareAndSwap(head, c) {
			debugPrintf("registered %s %p\n", c.Name(), f.counters.Load())
			return
		}
		debugPrintf("register %s cas2 failed %p %p\n", c.Name(), f.counters.Load(), head)
	}
}

// invalidateCounters marks as invalid all the pointers
// held by f's counters and then refreshes them.
//

	}
	p.FuncIdx, err = rdu32()
	if err != nil {
		return false, err
	}
	if cap(p.Counters) < 1024 {
		p.Counters = make([]uint32, 0, 1024)
	}
	p.Counters = p.Counters[:0]
	for i := uint32(0); i < nc; i++ {
		v, err := rdu32()
		if err != nil {
			return false, err
		}
		p.Counters = append(p.Counters, v)
	}
	return true, nil

	counters := make([]*fakePerfCounterImpl, 8)
	for i := 0; i < 8; i++ {
		counters[i] = &fakePerfCounterImpl{
			name:       fakeAdapterName,
			value:      1,
			raiseError: raiseError,
		}
	}
	return &networkCounter{
		packetsReceivedPerSecondCounter: counters[0],
		packetsSentPerSecondCounter:     counters[1],
		bytesReceivedPerSecondCounter:   counters[2],

// for inlined functions and adjusts the return program counters into
// call program counters. Iterating over the returned slice of PCs
// directly is discouraged, as is using [FuncForPC] on any of the
// returned PCs, since these cannot account for inlining or return
// program counter adjustment.
func Callers(skip int, pc []uintptr) int {
	// runtime.callers uses pc.array==nil as a signal

	//       if alwaysTrue() {
	//         XYZ()                // counter update here
	//       }
	//     }
	//
	// In the instrumented version of ABC, the prolog of the function
	// will contain a series of stores to the initial portion of the
	// counter array to write number-of-counters, pkgid, funcid. Later
	// in the function there is also a store to increment a counter
	// for the block containing the call to XYZ(). If the CPU is

func main() {
	log.SetFlags(0)
	telemetry.Start() // Open the telemetry counter file so counters can be written to it.
	handleChdirFlag()
	toolchain.Select()

	telemetry.StartWithUpload() // Run the upload process. Opening the counter file is idempotent.
	flag.Usage = base.Usage
	flag.Parse()
	telemetry.Inc("go/invocations")

// RemoveDirsOneFilesystem will remove only directories and returns an error if
// it encounters any files in the directory tree. It makes sure it does not
// cross mount boundaries, i.e. it returns an error rather than remove dirs
// from another filesystem. It removes everything it can but returns the first
// error it encounters. If the path does not exist, it returns nil (no error).

				}
				return
			}

			// There are some counters that we can't expect to see any non-zero values, like the
			// networking-related counters.
			if tc.skipCheck {
				return
			}

			// Wait until we get a non-zero perf counter data.
			if pollErr := wait.Poll(100*time.Millisecond, 5*perfCounterUpdatePeriod, func() (bool, error) {
				data, err := counter.getData()
				if err != nil {
					return false, err

  //   running pods are terminated.
  // - Ignore: indicates that the counter towards the .backoffLimit is not
  //   incremented and a replacement pod is created.
  // - Count: indicates that the pod is handled in the default way - the
  //   counter towards the .backoffLimit is incremented.
  // Additional values are considered to be added in the future. Clients should