# We then walk this MIB and create a flattened sysctl name to OID hash.
#

use strict;

my $debug = 0;
my %ctls = ();

my @headers = qw (
	sys/sysctl.h
	sys/socket.h
	sys/tty.h
	sys/malloc.h
	sys/mount.h
	sys/namei.h
	sys/sem.h
	sys/shm.h
	sys/vmmeter.h
	uvm/uvm_param.h
	uvm/uvm_swap_encrypt.h
	ddb/db_var.h
	net/if.h
	net/if_pfsync.h
	net/pipex.h
	netinet/in.h
	netinet/icmp_var.h

static void *sendthr(void *arg) {
	pthread_t th = *(pthread_t*)arg;
	while (1) {
		int r = pthread_kill(th, SIGWINCH);
		if (r < 0)
			break;
	}
	return 0;
}

static void foo() {
	pthread_t *th = malloc(sizeof(pthread_t));
	pthread_t th2;
	pthread_create(th, 0, thr, 0);
	pthread_create(&th2, 0, sendthr, th);
	pthread_join(*th, 0);
}
*/
import "C"

import (
	"time"
)

//export go_callback

}

static void* spin(void *arg) {
	size_t n;
	struct timeval tvstart, tvnow;
	int diff;
	void *prev;
	void *cur;

	prev = NULL;
	gettimeofday(&tvstart, NULL);
	for (n = 0; n < 1<<20; n++) {
		cur = malloc(n);
		free(prev);
		prev = cur;

		gettimeofday(&tvnow, NULL);
		diff = (tvnow.tv_sec - tvstart.tv_sec) * 1000 * 1000 + (tvnow.tv_usec - tvstart.tv_usec);

		// Profile frequency is 100Hz so we should definitely

}

//go:nosplit
func semacreate(mp *m) {
	if mp.waitsema != 0 {
		return
	}

	var sem *semt

	// Call libc's malloc rather than malloc. This will
	// allocate space on the C heap. We can't call mallocgc
	// here because it could cause a deadlock.
	sem = (*semt)(malloc(unsafe.Sizeof(*sem)))
	if sem_init(sem, 0, 0) != 0 {
		throw("sem_init")
	}
	mp.waitsema = uintptr(unsafe.Pointer(sem))
}

//go:nosplit

	_C_uint            = C.uint
	_C_socklen_t       = C.socklen_t
	_C_struct_addrinfo = C.struct_addrinfo
	_C_struct_sockaddr = C.struct_sockaddr
)

func _C_malloc(n uintptr) unsafe.Pointer { return C.malloc(C.size_t(n)) }
func _C_free(p unsafe.Pointer)           { C.free(p) }

func _C_ai_addr(ai *_C_struct_addrinfo) **_C_struct_sockaddr { return &ai.ai_addr }

#include <stdlib.h>
#include <sys/time.h>

void spin() {
	size_t n;
	struct timeval tvstart, tvnow;
	int diff;
	void *prev = NULL, *cur;

	gettimeofday(&tvstart, NULL);
	for (n = 0; n < 1<<20; n++) {
		cur = malloc(n);
		free(prev);
		prev = cur;

		gettimeofday(&tvnow, NULL);
		diff = (tvnow.tv_sec - tvstart.tv_sec) * 1000 * 1000 + (tvnow.tv_usec - tvstart.tv_usec);

		// Profile frequency is 100Hz so we should definitely

#cgo LDFLAGS: -fsanitize=memory
#cgo CPPFLAGS: -fsanitize=memory

#include <stdint.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
	uintptr_t a[20];
} S;

S f() {
	S *p;

	p = (S *)(malloc(sizeof(S)));
	p->a[0] = 0;
	return *p;
}
*/
import "C"

// allocateStack extends the stack so that stack copying doesn't
// confuse the msan data structures.
//
//go:noinline

		}
	})
	if allocs != 0 {
		t.Fatalf("mallocs per encode of type Bench: %v; wanted 0\n", allocs)
	}
}

func TestCountDecodeMallocs(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping malloc count in short mode")
	}
	if runtime.GOMAXPROCS(0) > 1 {
		t.Skip("skipping; GOMAXPROCS>1")
	}

	const N = 1000

	var buf bytes.Buffer
	enc := NewEncoder(&buf)

		len(a.B.C1.D2.E2.F7) != 0 ||
		len(a.B.C1.D2.E2.F8) != 0 ||
		len(a.B.C1.D2.E2.F9) != 0 ||
		len(a.B.C1.D2.E2.F10) != 0 ||
		len(a.B.C1.D2.E2.F11) != 0 ||
		len(a.B.C1.D2.E2.F16) != 0 {
		panic("bad")
	}
	C.malloc(100)
}

type A struct {
	B
}

type B struct {
	C1 C
	C2 C
}

type C struct {
	D1 D
	D2 D
}

type D struct {
	E1 E
	E2 E
	E3 E
	E4 E
}

	go func() {
		runtime.LockOSThread()
		for {
			select {
			case <-done:
				return
			default:
				runtime.Gosched()
			}
		}
	}()

	runtime.GC()
	// Trigger GC from malloc.
	n := 512
	for i := 0; i < n; i++ {
		_ = make([]byte, 1<<20)
	}

	// Create a bunch of busy goroutines to load all Ps.
	for p := 0; p < 10; p++ {
		wg.Add(1)
		go func() {
			// Do something useful.