plan 9: dirty multithreading (need to link with dav1d until this is moved somewhere else)

Sigrid Haflínudóttir committed 6 years agoplan9_0

Commit c097de81 parent ba694339 files · +152 −6Browse files

Unified · Split

9 files

mkfile +1 −1
plan9/pthread.h +75 −0
plan9/sched.h +0 −0
plan9/semaphore.h +50 −0
plan9/vpx_config.h +13 −4
vp8/common/generic/systemdependent.c +7 −1
vp8/vp8_dx_iface.c +1 −0
vpx_util/endian_inl.h +2 −0
vpx_util/vpx_thread.h +3 −0

@@ -60,7 +60,7 @@ OFILES=\ · 59 unmodified lines
60	detokenize.$O\	60	detokenize.$O\
61	# error_concealment.$O\	61	# error_concealment.$O\
62	onyxd_if.$O\	62	onyxd_if.$O\
63	# threading.$O\	63	threading.$O\
64	# vp8/encoder \	64	# vp8/encoder \
65	bitstream.$O\	65	bitstream.$O\
66	boolhuff.$O\	66	boolhuff.$O\

plan9/pthread.h+75−0

@@ -0,0 +1,75 @@
	1	#ifndef __pthread_h__
	2	#define __pthread_h__
	3
	4	typedef struct pthread_t pthread_t;
	5	typedef struct pthread_cond_t pthread_cond_t;
	6	typedef struct pthread_once_t pthread_once_t;
	7	typedef struct pthread_mutex_t pthread_mutex_t;
	8
	9	struct pthread_cond_t {
	10	Rendez;
	11	QLock lock;
	12	};
	13
	14	struct pthread_once_t {
	15	QLock;
	16	int done;
	17	};
	18
	19	struct pthread_mutex_t {
	20	QLock;
	21	};
	22
	23	#define PTHREAD_ONCE_INIT {0}
	24
	25	struct pthread_t {
	26	void *waitchan;
	27	void (func)(void*);
	28	void *arg;
	29	int pid;
	30	};
	31
	32	typedef struct {
	33	unsigned stack_size;
	34	} pthread_attr_t;
	35
	36	void dav1d_set_thread_name(const char *const name);
	37	int dav1d_pthread_join(pthread_t thread, void *res);
	38	#define pthread_join(thread, res) dav1d_pthread_join(&(thread), res)
	39
	40	static int pthread_attr_init(pthread_attr_t *const attr) {
	41	attr->stack_size = 0;
	42	return 0;
	43	}
	44
	45	static int pthread_attr_destroy(pthread_attr_t *const attr) {
	46	USED(attr);
	47	return 0;
	48	}
	49
	50	static int pthread_attr_setstacksize(pthread_attr_t *const attr,
	51	const int stack_size)
	52	{
	53	attr->stack_size = stack_size;
	54	return 0;
	55	}
	56
	57	static int
	58	pthread_mutex_trylock(pthread_mutex_t *const mutex)
	59	{
	60	return canqlock(mutex) ? 0 : -1;
	61	}
	62
	63	int pthread_mutex_init(pthread_mutex_t const mutex, const void const attr);
	64	int pthread_mutex_destroy(pthread_mutex_t *const mutex);
	65	int pthread_mutex_lock(pthread_mutex_t *const mutex);
	66	int pthread_mutex_unlock(pthread_mutex_t *const mutex);
	67	int pthread_cond_init(pthread_cond_t const cond, const void const attr);
	68	int pthread_cond_destroy(pthread_cond_t *const cond);
	69	int pthread_cond_wait(pthread_cond_t const cond, pthread_mutex_t const mutex);
	70	int pthread_cond_signal(pthread_cond_t *const cond);
	71	int pthread_cond_broadcast(pthread_cond_t *const cond);
	72	int pthread_create(pthread_t thread, const pthread_attr_t attr, void (func)(void), void arg);
	73	int pthread_once(pthread_once_t once_control, void (init_routine)(void));
	74
	75	#endif

plan9/sched.h+0−0

Empty file added.

plan9/semaphore.h+50−0

@@ -0,0 +1,50 @@
	1	#ifndef __semaphore_h__
	2	#define __semaphore_h__
	3
	4	typedef struct sem_t sem_t;
	5
	6	struct sem_t {
	7	Channel *c;
	8	};
	9
	10	static int
	11	sem_post(sem_t *s)
	12	{
	13	void *p;
	14
	15	if(s == nil \|\| s->c == nil)
	16	return -1;
	17	nbrecv(s->c, &p);
	18
	19	return 0;
	20	}
	21
	22	static int
	23	sem_wait(sem_t *s)
	24	{
	25	void *p;
	26
	27	if(s == nil \|\| s->c == nil)
	28	return -1;
	29	sendp(s->c, nil);
	30
	31	return 0;
	32	}
	33
	34	static int
	35	sem_init(sem_t *s, int pshared, unsigned int value)
	36	{
	37	s->c = chancreate(sizeof(void*), value);
	38
	39	return 0;
	40	}
	41
	42	static int
	43	sem_destroy(sem_t *s)
	44	{
	45	chanclose(s->c);
	46
	47	return 0;
	48	}
	49
	50	#endif

plan9/vpx_config.h+13−4

 #include <u.h>
 #include <libc.h>
+#include <thread.h>
 #include </sys/include/stdio.h>
 typedef u8int uint8_t;
 typedef u16int uint16_t;
 double round(double);
 #define logf log
+#define sched_yield() yield()
+#define __atomic_load_n(p,o) *(p)
+#define __atomic_store_n(p,v,x) do { *(p) = (v); } while(0)
+#define __has_builtin(x) 1
+#define __ATOMIC_RELEASE 0
+#define __ATOMIC_ACQUIRE 1
 #define RESTRICT
 #define INLINE      inline
 #define VPX_ARCH_ARM 0
 #define HAVE_VSX 0
 #define HAVE_MMI 0
 #define HAVE_VPX_PORTS 0
-#define HAVE_PTHREAD_H 0
+#define HAVE_PTHREAD_H 1
 #define HAVE_UNISTD_H 1
 #define CONFIG_DEPENDENCY_TRACKING 1
 #define CONFIG_EXTERNAL_BUILD 0
 #define CONFIG_RUNTIME_CPU_DETECT 1
 #define CONFIG_POSTPROC 0
 #define CONFIG_VP9_POSTPROC 0
-#define CONFIG_MULTITHREAD 0
+#define CONFIG_MULTITHREAD 1
 #define CONFIG_INTERNAL_STATS 0
 #define CONFIG_VP8_ENCODER 1
 #define CONFIG_VP8_DECODER 1
 #define CONFIG_REALTIME_ONLY 0
 #define CONFIG_ONTHEFLY_BITPACKING 0
 #define CONFIG_ERROR_CONCEALMENT 0
-#define CONFIG_SHARED 1
+#define CONFIG_SHARED 0
 #define CONFIG_STATIC 1
 #define CONFIG_SMALL 0
 #define CONFIG_POSTPROC_VISUALIZER 0
 #define CONFIG_OS_SUPPORT 1
-#define CONFIG_UNIT_TESTS 1
+#define CONFIG_UNIT_TESTS 0
 #define CONFIG_WEBM_IO 0
 #define CONFIG_LIBYUV 0
 #define CONFIG_DECODE_PERF_TESTS 0

vp8/common/generic/systemdependent.c+7−1

 #endif
 #if CONFIG_MULTITHREAD
-static int get_cpu_count() {
+static int get_cpu_count(void) {
   int core_count = 16;
 #if HAVE_UNISTD_H && !defined(__OS2__)
       if (status == PROC_ONLINE) core_count++;
     }
   }
+#elif defined(__plan9__)
+  {
+    char *s = getenv("NPROC");
+    core_count = atoi(s ? s : "1");
+    fprint(2, "core count: %d\n", core_count);
+  }
 #else
 /* other platforms */
 #endif

vp8/vp8_dx_iface.c+1−0

@@ -11,6 +11,7 @@ · 10 unmodified lines
11	#include <assert.h>	11	#include <assert.h>
12	#include <stdlib.h>	12	#include <stdlib.h>
13	#include <string.h>	13	#include <string.h>
		14	#include "vpx_config.h"
14	#include "./vp8_rtcd.h"	15	#include "./vp8_rtcd.h"
15	#include "./vpx_dsp_rtcd.h"	16	#include "./vpx_dsp_rtcd.h"
16	#include "./vpx_scale_rtcd.h"	17	#include "./vpx_scale_rtcd.h"

vpx_util/endian_inl.h+2−0

 #define HToBE32(X) BSwap32(X)
 #endif
+#ifndef __plan9__
 #if LOCAL_GCC_PREREQ(4, 8) || __has_builtin(__builtin_bswap16)
 #define HAVE_BUILTIN_BSWAP16
 #endif
 #if LOCAL_GCC_PREREQ(4, 3) || __has_builtin(__builtin_bswap64)
 #define HAVE_BUILTIN_BSWAP64
 #endif
+#endif
 #if HAVE_MIPS32 && defined(__mips__) && !defined(__mips64) && \
     defined(__mips_isa_rev) && (__mips_isa_rev >= 2) && (__mips_isa_rev < 6)

vpx_util/vpx_thread.h+3−0

 // Platform-dependent implementation details for the worker.
 typedef struct VPxWorkerImpl VPxWorkerImpl;
+#pragma incomplete VPxWorkerImpl
 // Synchronization object used to launch job in the worker thread
 typedef struct {
   void *data2;         // second argument passed to 'hook'
   int had_error;       // return value of the last call to 'hook'
 } VPxWorker;
+#pragma incomplete VPxWorker
 // The interface for all thread-worker related functions. All these functions
 // must be implemented.
   // must call reset() again.
   void (*end)(VPxWorker *const worker);
 } VPxWorkerInterface;
+#pragma incomplete VPxWorkerInterface
 // Install a new set of threading functions, overriding the defaults. This
 // should be done before any workers are started, i.e., before any encoding or

plan 9: dirty multithreading (need to link with dav1d until this is moved somewhere else)

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code