gtsocial-umbx

pthread.go (13081B)

---

 // Copyright 2021 The Libc 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 libc // import "modernc.org/libc"
 
 import (
 	"runtime"
 	"sync"
 	"sync/atomic"
 	"time"
 	"unsafe"
 
 	"modernc.org/libc/errno"
 	"modernc.org/libc/pthread"
 	"modernc.org/libc/sys/types"
 	ctime "modernc.org/libc/time"
 )
 
 var (
 	mutexes   = map[uintptr]*mutex{}
 	mutexesMu sync.Mutex
 
 	threads   = map[int32]*TLS{}
 	threadsMu sync.Mutex
 
 	threadKey            pthread.Pthread_key_t
 	threadKeyDestructors = map[pthread.Pthread_key_t][]uintptr{} // key: []destructor
 	threadsKeysMu        sync.Mutex
 
 	conds   = map[uintptr]*cond{}
 	condsMu sync.Mutex
 )
 
 // Thread local storage.
 type TLS struct {
 	errnop uintptr
 	pthreadData
 	stack stackHeader
 
 	ID                 int32
 	reentryGuard       int32 // memgrind
 	stackHeaderBalance int32
 }
 
 var errno0 int32 // Temp errno for NewTLS
 
 func NewTLS() *TLS {
 	return newTLS(false)
 }
 
 func newTLS(detached bool) *TLS {
 	id := atomic.AddInt32(&tid, 1)
 	t := &TLS{ID: id, errnop: uintptr(unsafe.Pointer(&errno0))}
 	t.pthreadData.init(t, detached)
 	if memgrind {
 		atomic.AddInt32(&tlsBalance, 1)
 	}
 	t.errnop = t.Alloc(int(unsafe.Sizeof(int32(0))))
 	*(*int32)(unsafe.Pointer(t.errnop)) = 0
 	return t
 }
 
 // Pthread specific part of a TLS.
 type pthreadData struct {
 	done   chan struct{}
 	kv     map[pthread.Pthread_key_t]uintptr
 	retVal uintptr
 	wait   chan struct{} // cond var interaction
 
 	detached bool
 }
 
 func (d *pthreadData) init(t *TLS, detached bool) {
 	d.detached = detached
 	d.wait = make(chan struct{}, 1)
 	if detached {
 		return
 	}
 
 	d.done = make(chan struct{})
 
 	threadsMu.Lock()
 
 	defer threadsMu.Unlock()
 
 	threads[t.ID] = t
 }
 
 func (d *pthreadData) close(t *TLS) {
 	threadsMu.Lock()
 
 	defer threadsMu.Unlock()
 
 	delete(threads, t.ID)
 }
 
 // int pthread_attr_destroy(pthread_attr_t *attr);
 func Xpthread_attr_destroy(t *TLS, pAttr uintptr) int32 {
 	return 0
 }
 
 // int pthread_attr_setscope(pthread_attr_t *attr, int contentionscope);
 func Xpthread_attr_setscope(t *TLS, pAttr uintptr, contentionScope int32) int32 {
 	switch contentionScope {
 	case pthread.PTHREAD_SCOPE_SYSTEM:
 		return 0
 	default:
 		panic(todo("", contentionScope))
 	}
 }
 
 // int pthread_attr_setstacksize(pthread_attr_t *attr, size_t stacksize);
 func Xpthread_attr_setstacksize(t *TLS, attr uintptr, stackSize types.Size_t) int32 {
 	panic(todo(""))
 }
 
 // Go side data of pthread_cond_t.
 type cond struct {
 	sync.Mutex
 	waiters map[*TLS]struct{}
 }
 
 func newCond() *cond {
 	return &cond{
 		waiters: map[*TLS]struct{}{},
 	}
 }
 
 func (c *cond) signal(all bool) int32 {
 	if c == nil {
 		return errno.EINVAL
 	}
 
 	c.Lock()
 
 	defer c.Unlock()
 
 	// The pthread_cond_broadcast() and pthread_cond_signal() functions shall have
 	// no effect if there are no threads currently blocked on cond.
 	for tls := range c.waiters {
 		tls.wait <- struct{}{}
 		delete(c.waiters, tls)
 		if !all {
 			break
 		}
 	}
 	return 0
 }
 
 // The pthread_cond_init() function shall initialize the condition variable
 // referenced by cond with attributes referenced by attr. If attr is NULL, the
 // default condition variable attributes shall be used; the effect is the same
 // as passing the address of a default condition variable attributes object.
 // Upon successful initialization, the state of the condition variable shall
 // become initialized.
 //
 // If successful, the pthread_cond_destroy() and pthread_cond_init() functions
 // shall return zero; otherwise, an error number shall be returned to indicate
 // the error.
 //
 // int pthread_cond_init(pthread_cond_t *restrict cond, const pthread_condattr_t *restrict attr);
 func Xpthread_cond_init(t *TLS, pCond, pAttr uintptr) int32 {
 	if pCond == 0 {
 		return errno.EINVAL
 	}
 
 	if pAttr != 0 {
 		panic(todo("%#x %#x", pCond, pAttr))
 	}
 
 	condsMu.Lock()
 
 	defer condsMu.Unlock()
 
 	conds[pCond] = newCond()
 	return 0
 }
 
 // int pthread_cond_destroy(pthread_cond_t *cond);
 func Xpthread_cond_destroy(t *TLS, pCond uintptr) int32 {
 	if pCond == 0 {
 		return errno.EINVAL
 	}
 
 	condsMu.Lock()
 
 	defer condsMu.Unlock()
 
 	cond := conds[pCond]
 	if cond == nil {
 		return errno.EINVAL
 	}
 
 	cond.Lock()
 
 	defer cond.Unlock()
 
 	if len(cond.waiters) != 0 {
 		return errno.EBUSY
 	}
 
 	delete(conds, pCond)
 	return 0
 }
 
 // int pthread_cond_signal(pthread_cond_t *cond);
 func Xpthread_cond_signal(t *TLS, pCond uintptr) int32 {
 	return condSignal(pCond, false)
 }
 
 // int pthread_cond_broadcast(pthread_cond_t *cond);
 func Xpthread_cond_broadcast(t *TLS, pCond uintptr) int32 {
 	return condSignal(pCond, true)
 }
 
 func condSignal(pCond uintptr, all bool) int32 {
 	if pCond == 0 {
 		return errno.EINVAL
 	}
 
 	condsMu.Lock()
 	cond := conds[pCond]
 	condsMu.Unlock()
 
 	return cond.signal(all)
 }
 
 // int pthread_cond_wait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex);
 func Xpthread_cond_wait(t *TLS, pCond, pMutex uintptr) int32 {
 	if pCond == 0 {
 		return errno.EINVAL
 	}
 
 	condsMu.Lock()
 	cond := conds[pCond]
 	if cond == nil { // static initialized condition variables are valid
 		cond = newCond()
 		conds[pCond] = cond
 	}
 
 	cond.Lock()
 	cond.waiters[t] = struct{}{}
 	cond.Unlock()
 
 	condsMu.Unlock()
 
 	mutexesMu.Lock()
 	mu := mutexes[pMutex]
 	mutexesMu.Unlock()
 
 	mu.Unlock()
 	<-t.wait
 	mu.Lock()
 	return 0
 }
 
 // int pthread_cond_timedwait(pthread_cond_t *restrict cond, pthread_mutex_t *restrict mutex, const struct timespec *restrict abstime);
 func Xpthread_cond_timedwait(t *TLS, pCond, pMutex, pAbsTime uintptr) int32 {
 	if pCond == 0 {
 		return errno.EINVAL
 	}
 
 	condsMu.Lock()
 	cond := conds[pCond]
 	if cond == nil { // static initialized condition variables are valid
 		cond = newCond()
 		conds[pCond] = cond
 	}
 
 	cond.Lock()
 	cond.waiters[t] = struct{}{}
 	cond.Unlock()
 
 	condsMu.Unlock()
 
 	mutexesMu.Lock()
 	mu := mutexes[pMutex]
 	mutexesMu.Unlock()
 
 	deadlineSecs := (*ctime.Timespec)(unsafe.Pointer(pAbsTime)).Ftv_sec
 	deadlineNsecs := (*ctime.Timespec)(unsafe.Pointer(pAbsTime)).Ftv_nsec
 	deadline := time.Unix(int64(deadlineSecs), int64(deadlineNsecs))
 	d := deadline.Sub(time.Now())
 	switch {
 	case d <= 0:
 		return errno.ETIMEDOUT
 	default:
 		to := time.After(d)
 		mu.Unlock()
 
 		defer mu.Lock()
 
 		select {
 		case <-t.wait:
 			return 0
 		case <-to:
 			cond.Lock()
 
 			defer cond.Unlock()
 
 			delete(cond.waiters, t)
 			return errno.ETIMEDOUT
 		}
 	}
 }
 
 // Go side data of pthread_mutex_t
 type mutex struct {
 	sync.Mutex
 	typ  int // PTHREAD_MUTEX_NORMAL, ...
 	wait sync.Mutex
 
 	id  int32 // owner's t.ID
 	cnt int32
 
 	robust bool
 }
 
 func newMutex(typ int) *mutex {
 	return &mutex{
 		typ: typ,
 	}
 }
 
 func (m *mutex) lock(id int32) int32 {
 	if m.robust {
 		panic(todo(""))
 	}
 
 	// If successful, the pthread_mutex_lock() and pthread_mutex_unlock() functions
 	// shall return zero; otherwise, an error number shall be returned to indicate
 	// the error.
 	switch m.typ {
 	case pthread.PTHREAD_MUTEX_NORMAL:
 		// If the mutex type is PTHREAD_MUTEX_NORMAL, deadlock detection shall not be
 		// provided. Attempting to relock the mutex causes deadlock. If a thread
 		// attempts to unlock a mutex that it has not locked or a mutex which is
 		// unlocked, undefined behavior results.
 		m.Lock()
 		m.id = id
 		return 0
 	case pthread.PTHREAD_MUTEX_RECURSIVE:
 		for {
 			m.Lock()
 			switch m.id {
 			case 0:
 				m.cnt = 1
 				m.id = id
 				m.wait.Lock()
 				m.Unlock()
 				return 0
 			case id:
 				m.cnt++
 				m.Unlock()
 				return 0
 			}
 
 			m.Unlock()
 			m.wait.Lock()
 			m.wait.Unlock()
 		}
 	default:
 		panic(todo("", m.typ))
 	}
 }
 
 func (m *mutex) tryLock(id int32) int32 {
 	if m.robust {
 		panic(todo(""))
 	}
 
 	switch m.typ {
 	case pthread.PTHREAD_MUTEX_NORMAL:
 		return errno.EBUSY
 	case pthread.PTHREAD_MUTEX_RECURSIVE:
 		m.Lock()
 		switch m.id {
 		case 0:
 			m.cnt = 1
 			m.id = id
 			m.wait.Lock()
 			m.Unlock()
 			return 0
 		case id:
 			m.cnt++
 			m.Unlock()
 			return 0
 		}
 
 		m.Unlock()
 		return errno.EBUSY
 	default:
 		panic(todo("", m.typ))
 	}
 }
 
 func (m *mutex) unlock() int32 {
 	if m.robust {
 		panic(todo(""))
 	}
 
 	// If successful, the pthread_mutex_lock() and pthread_mutex_unlock() functions
 	// shall return zero; otherwise, an error number shall be returned to indicate
 	// the error.
 	switch m.typ {
 	case pthread.PTHREAD_MUTEX_NORMAL:
 		// If the mutex type is PTHREAD_MUTEX_NORMAL, deadlock detection shall not be
 		// provided. Attempting to relock the mutex causes deadlock. If a thread
 		// attempts to unlock a mutex that it has not locked or a mutex which is
 		// unlocked, undefined behavior results.
 		m.id = 0
 		m.Unlock()
 		return 0
 	case pthread.PTHREAD_MUTEX_RECURSIVE:
 		m.Lock()
 		m.cnt--
 		if m.cnt == 0 {
 			m.id = 0
 			m.wait.Unlock()
 		}
 		m.Unlock()
 		return 0
 	default:
 		panic(todo("", m.typ))
 	}
 }
 
 // int pthread_mutex_destroy(pthread_mutex_t *mutex);
 func Xpthread_mutex_destroy(t *TLS, pMutex uintptr) int32 {
 	mutexesMu.Lock()
 
 	defer mutexesMu.Unlock()
 
 	delete(mutexes, pMutex)
 	return 0
 }
 
 // int pthread_mutex_lock(pthread_mutex_t *mutex);
 func Xpthread_mutex_lock(t *TLS, pMutex uintptr) int32 {
 	mutexesMu.Lock()
 	mu := mutexes[pMutex]
 	if mu == nil { // static initialized mutexes are valid
 		mu = newMutex(int(X__ccgo_getMutexType(t, pMutex)))
 		mutexes[pMutex] = mu
 	}
 	mutexesMu.Unlock()
 	return mu.lock(t.ID)
 }
 
 // int pthread_mutex_trylock(pthread_mutex_t *mutex);
 func Xpthread_mutex_trylock(t *TLS, pMutex uintptr) int32 {
 	mutexesMu.Lock()
 	mu := mutexes[pMutex]
 	if mu == nil { // static initialized mutexes are valid
 		mu = newMutex(int(X__ccgo_getMutexType(t, pMutex)))
 		mutexes[pMutex] = mu
 	}
 	mutexesMu.Unlock()
 	return mu.tryLock(t.ID)
 }
 
 // int pthread_mutex_unlock(pthread_mutex_t *mutex);
 func Xpthread_mutex_unlock(t *TLS, pMutex uintptr) int32 {
 	mutexesMu.Lock()
 
 	defer mutexesMu.Unlock()
 
 	return mutexes[pMutex].unlock()
 }
 
 // int pthread_key_create(pthread_key_t *key, void (*destructor)(void*));
 func Xpthread_key_create(t *TLS, pKey, destructor uintptr) int32 {
 	threadsKeysMu.Lock()
 
 	defer threadsKeysMu.Unlock()
 
 	threadKey++
 	r := threadKey
 	if destructor != 0 {
 		threadKeyDestructors[r] = append(threadKeyDestructors[r], destructor)
 	}
 	*(*pthread.Pthread_key_t)(unsafe.Pointer(pKey)) = pthread.Pthread_key_t(r)
 	return 0
 }
 
 // int pthread_key_delete(pthread_key_t key);
 func Xpthread_key_delete(t *TLS, key pthread.Pthread_key_t) int32 {
 	if _, ok := t.kv[key]; ok {
 		delete(t.kv, key)
 		return 0
 	}
 
 	panic(todo(""))
 
 }
 
 // void *pthread_getspecific(pthread_key_t key);
 func Xpthread_getspecific(t *TLS, key pthread.Pthread_key_t) uintptr {
 	return t.kv[key]
 }
 
 // int pthread_setspecific(pthread_key_t key, const void *value);
 func Xpthread_setspecific(t *TLS, key pthread.Pthread_key_t, value uintptr) int32 {
 	if t.kv == nil {
 		t.kv = map[pthread.Pthread_key_t]uintptr{}
 	}
 	t.kv[key] = value
 	return 0
 }
 
 // int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine) (void *), void *arg);
 func Xpthread_create(t *TLS, pThread, pAttr, startRoutine, arg uintptr) int32 {
 	fn := (*struct {
 		f func(*TLS, uintptr) uintptr
 	})(unsafe.Pointer(&struct{ uintptr }{startRoutine})).f
 	detached := pAttr != 0 && X__ccgo_pthreadAttrGetDetachState(t, pAttr) == pthread.PTHREAD_CREATE_DETACHED
 	tls := newTLS(detached)
 	*(*pthread.Pthread_t)(unsafe.Pointer(pThread)) = pthread.Pthread_t(tls.ID)
 
 	go func() {
 		Xpthread_exit(tls, fn(tls, arg))
 	}()
 
 	return 0
 }
 
 // int pthread_detach(pthread_t thread);
 func Xpthread_detach(t *TLS, thread pthread.Pthread_t) int32 {
 	threadsMu.Lock()
 	threads[int32(thread)].detached = true
 	threadsMu.Unlock()
 	return 0
 }
 
 // int pthread_equal(pthread_t t1, pthread_t t2);
 func Xpthread_equal(t *TLS, t1, t2 pthread.Pthread_t) int32 {
 	return Bool32(t1 == t2)
 }
 
 // void pthread_exit(void *value_ptr);
 func Xpthread_exit(t *TLS, value uintptr) {
 	t.retVal = value
 
 	// At thread exit, if a key value has a non-NULL destructor pointer, and the
 	// thread has a non-NULL value associated with that key, the value of the key
 	// is set to NULL, and then the function pointed to is called with the
 	// previously associated value as its sole argument. The order of destructor
 	// calls is unspecified if more than one destructor exists for a thread when it
 	// exits.
 	for k, v := range t.kv {
 		if v == 0 {
 			continue
 		}
 
 		threadsKeysMu.Lock()
 		destructors := threadKeyDestructors[k]
 		threadsKeysMu.Unlock()
 
 		for _, destructor := range destructors {
 			delete(t.kv, k)
 			panic(todo("%#x", destructor)) //TODO call destructor(v)
 		}
 	}
 
 	switch {
 	case t.detached:
 		threadsMu.Lock()
 		delete(threads, t.ID)
 		threadsMu.Unlock()
 	default:
 		close(t.done)
 	}
 	runtime.Goexit()
 }
 
 // int pthread_join(pthread_t thread, void **value_ptr);
 func Xpthread_join(t *TLS, thread pthread.Pthread_t, pValue uintptr) int32 {
 	threadsMu.Lock()
 	tls := threads[int32(thread)]
 	delete(threads, int32(thread))
 	threadsMu.Unlock()
 	<-tls.done
 	if pValue != 0 {
 		*(*uintptr)(unsafe.Pointer(pValue)) = tls.retVal
 	}
 	return 0
 }
 
 // pthread_t pthread_self(void);
 func Xpthread_self(t *TLS) pthread.Pthread_t {
 	return pthread.Pthread_t(t.ID)
 }