started    = atomic.Uint32{}
)

// same as CTHREADS in C, make sure all the C threads are actually started.
const cThreadNum = 2

func init() {
	register("EnsureBindM", EnsureBindM)
}

//export GoCheckBindM
func GoCheckBindM(thread uintptr) {
	// Wait all threads start
	if started.Load() != cThreadNum {
		// Only once for each thread, since it will wait all threads start.
		started.Add(1)

//go:build test_run

// Pass numbers along a chain of threads.

package main

import (
	"runtime"
	"strconv"

	"cgostdio/stdio"
)

const N = 10
const R = 5

func link(left chan<- int, right <-chan int) {
	// Keep the links in dedicated operating system
	// threads, so that this program tests coordination
	// between pthreads and not just goroutines.
	runtime.LockOSThread()
	for {

#include "libcgo.h"

/*
 * Assumed POSIX compliant libc system call wrappers. For linux, the
 * glibc/nptl/setxid mechanism ensures that POSIX semantics are
 * honored for all pthreads (by default), and this in turn with cgo
 * ensures that all Go threads launched with cgo are kept in sync for
 * these function calls.
 */

// argset_t matches runtime/cgocall.go:argset.
typedef struct {
	uintptr_t* args;
	uintptr_t retval;

							{SocketID: 1, Id: 8, Threads: []int{23, 63}},
							{SocketID: 1, Id: 9, Threads: []int{24, 64}},
							{SocketID: 1, Id: 16, Threads: []int{25, 65}},
							{SocketID: 1, Id: 17, Threads: []int{26, 66}},
							{SocketID: 1, Id: 18, Threads: []int{27, 67}},
							{SocketID: 1, Id: 24, Threads: []int{28, 68}},
							{SocketID: 1, Id: 25, Threads: []int{29, 69}},
						},
					},
					{Id: 3,

#include <pthread.h>
#include <unistd.h>
#include "_cgo_export.h"

#define CTHREADS 2
#define CHECKCALLS 100

static void* checkBindMThread(void* thread) {
	int i;
	for (i = 0; i < CHECKCALLS; i++) {
		GoCheckBindM((uintptr_t)thread);
		usleep(1);
	}
	return NULL;
}

void CheckBindM() {
	int i;
	pthread_t s[CTHREADS];

	for (i = 0; i < CTHREADS; i++) {
		pthread_create(&s[i], NULL, checkBindMThread, &s[i]);
	}

    }

    def "cleanup"() {
        lease?.leaseFinish()
        workerRegistry.stop()
    }

    def "executes all #runs operations in #threads threads"() {
        given:
        setupQueue(threads)
        def success = Mock(TestBuildOperation)

        when:
        runs.times { operationQueue.add(success) }

        and:

	// the garbage collector might create.
	const threads = 10

	var wg sync.WaitGroup
	wg.Add(threads)
	ts := syscall.NsecToTimespec((100 * time.Microsecond).Nanoseconds())
	for i := 0; i < threads; i++ {
		go func() {
			defer wg.Done()
			syscall.Nanosleep(&ts, nil)
		}()
	}
	wg.Wait()

        lock.lock()
        try {
            if (!threads.isEmpty()) {
                logger.log "waiting for ${threads.size()} test threads to complete."
            }

            while (!threads.isEmpty()) {
                if (!condition.awaitUntil(expiry)) {
                    break;
                }
            }

            if (!threads.isEmpty()) {

		// running threads with running Ps.
		ctx.IncThreadStateCount(ctx.elapsed(start), traceviewer.ThreadStateRunning, 1)
	}
	if from.Executing() {
		start := ev.Time()
		viewerEv.Name = "proc stop"
		viewerEv.Ts = ctx.elapsed(start)
		// TODO(mknyszek): We don't have a state machine for threads, so approximate
		// running threads with running Ps.

	for(i=0; i<max; i++)
		Add(i);
	return 0;
}

void
doAdd(int max, int nthread)
{
	enum { MaxThread = 20 };
	int i;
	uintptr_t thread_id[MaxThread];
	
	if(nthread > MaxThread)
		nthread = MaxThread;
	for(i=0; i<nthread; i++)
		thread_id[i] = _beginthreadex(0, 0, addThread, &max, 0, 0);
	for(i=0; i<nthread; i++) {
		WaitForSingleObject((HANDLE)thread_id[i], INFINITE);
		CloseHandle((HANDLE)thread_id[i]);