// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package ssa

type ID int32

// idAlloc provides an allocator for unique integers.
type idAlloc struct {
	last ID
}

// get allocates an ID and returns it. IDs are always > 0.
func (a *idAlloc) get() ID {
	x := a.last
	x++
	if x == 1<<31-1 {

// license that can be found in the LICENSE file.

// When the function Store an Arg and also use it in another place,
// be sure not to generate duplicated OpArgXXXReg values, which confuses
// the register allocator.

package main

//go:noinline
//go:registerparams
func F(x, y float32) {
	if x < 0 {
		panic("FAIL")
	}
	g = [4]float32{x, y, x, y}
}

var g [4]float32

func main() {
	F(1, 2)

// Copyright 2022 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package calloc

// This package contains a simple "batch" allocator for allocating
// coverage counters (slices of uint32 basically), for working with
// coverage data files. Collections of counter arrays tend to all be
// live/dead over the same time period, so a good fit for batch
// allocation.

		// don't put the allocator inside the embeddedEncodeFn as that would allocate memory on every call.
		// instead, we allocate the buffer for the entire watch session and release it when we close the connection.
		memoryAllocator = runtime.AllocatorPool.Get().(*runtime.Allocator)
		embeddedEncoder = runtime.NewEncoderWithAllocator(encoderWithAllocator, memoryAllocator)
	}

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package allocator

import (
	"math/big"
	"math/bits"
)

// countBits returns the number of set bits in n
func countBits(n *big.Int) int {
	var count int = 0
	for _, w := range n.Bits() {

    device_alloc_attr.set_on_host(false);
    device_allocator_ = device_->GetAllocator(device_alloc_attr);
  }

 protected:
  std::unique_ptr<Device> device_;
  Allocator* host_allocator_;
  Allocator* device_allocator_;
};

TEST_F(XlaHostSendRecvDeviceContextTest, CopyDeviceTensorToCPU) {
  SetDevice("GPU");
  Tensor origin_cpu_tensor(host_allocator_, DT_FLOAT, TensorShape({2, 2}));

}

var m = New[int]().M

func New[X any]() *T[X] {
	p := new(T[X])
	runtime.SetFinalizer(p, func(*T[X]) { close(done) })
	return p
}

type T[X any] [4]int // N.B., [4]int avoids runtime's tiny object allocator

func (*T[X]) M() {}

var done = make(chan int)

func wait() bool {
	for i := 0; i < 10; i++ {
		runtime.GC()
		select {
		case <-done:
			return true
		default:
		}
	}
	return false

				BaseChunkIdx + chunkIdxBigJump*1 + chunkIdxSmallOffset: {},
				BaseChunkIdx + chunkIdxBigJump*2:                       {},
			},
			hits: []hit{
				// We first allocate into A to set the page allocator's searchAddr to the
				// end of that chunk. That is the only purpose A serves.
				{1, PageBase(BaseChunkIdx, PallocChunkPages-1), 0},
				// Then, we make a big allocation that doesn't fit into B, and so must be

    TF_CHECK_OK(device_->TryGetDeviceContext(&device_context_));

    // Get the host allocator.
    AllocatorAttributes host_alloc_attr;
    host_alloc_attr.set_on_host(true);
    host_allocator_ = device_->GetAllocator(host_alloc_attr);

    // Get the device allocator. This should give us an AsyncValueAllocator.
    AllocatorAttributes device_alloc_attr;
    device_alloc_attr.set_on_host(false);

  std::shared_ptr<se::DeviceMemoryAllocator> allocator_ptr =
      GetAllocator(ctx->device(), stream, platform_info_);
  se::DeviceMemoryAllocator* allocator = allocator_ptr.get();
  XlaComputationLaunchContext launch_context(
      client, allocator, client->default_device_ordinal(),
      /*allocate_xla_tensors=*/platform_info_.xla_device_metadata() != nullptr,
      platform_info_.xla_device_metadata()