1 files changed, 0 insertions, 75 deletions

diff --git a/erts/emulator/beam/erl_async.c b/erts/emulator/beam/erl_async.c
index 9a93034fcb..75e88afc5e 100644
--- a/erts/emulator/beam/erl_async.c
+++ b/erts/emulator/beam/erl_async.c
@@ -34,9 +34,6 @@
 
 #define ERTS_ASYNC_PRINT_JOB 0
 
-#if !defined(ERTS_SMP) && defined(USE_THREADS) && !ERTS_USE_ASYNC_READY_Q
-#  error "Need async ready queue in non-smp case"
-#endif
 
 typedef struct _erl_async {
     DE_Handle*         hndl;   /* The DE_Handle is needed when port is gone */
@@ -46,16 +43,13 @@ typedef struct _erl_async {
     ErlDrvPDL          pdl;
     void (*async_invoke)(void*);
     void (*async_free)(void*);
-#if ERTS_USE_ASYNC_READY_Q
     Uint               sched_id;
     union {
 	ErtsThrQPrepEnQ_t *prep_enq;
 	ErtsThrQFinDeQ_t   fin_deq;
     } q;
-#endif
 } ErtsAsync;
 
-#if ERTS_USE_ASYNC_READY_Q
 
 /*
  * We can do without the enqueue mutex since it isn't needed for
@@ -94,7 +88,6 @@ typedef union {
     char align__[ERTS_ALC_CACHE_LINE_ALIGN_SIZE(sizeof(ErtsAsyncReadyQ))];
 } ErtsAlgndAsyncReadyQ;
 
-#endif /* ERTS_USE_ASYNC_READY_Q */
 
 typedef struct {
     ErtsThrQ_t thr_q;
@@ -119,9 +112,7 @@ typedef struct {
 	char align__[ERTS_ALC_CACHE_LINE_ALIGN_SIZE(sizeof(ErtsAsyncInit))];
     } init;
     ErtsAlgndAsyncQ *queue;
-#if ERTS_USE_ASYNC_READY_Q
     ErtsAlgndAsyncReadyQ *ready_queue;
-#endif
 } ErtsAsyncData;
 
 #if defined(USE_THREADS) && defined(USE_VM_PROBES)
@@ -140,15 +131,6 @@ int erts_async_thread_suggested_stack_size; /* Initialized by erl_init.c */
 
 static ErtsAsyncData *async;
 
-#ifndef USE_THREADS
-
-void
-erts_init_async(void)
-{
-
-}
-
-#else
 
 static void *async_main(void *);
 
@@ -158,7 +140,6 @@ async_q(int i)
     return &async->queue[i].aq;
 }
 
-#if ERTS_USE_ASYNC_READY_Q
 
 static ERTS_INLINE ErtsAsyncReadyQ *
 async_ready_q(Uint sched_id)
@@ -166,16 +147,13 @@ async_ready_q(Uint sched_id)
     return &async->ready_queue[((int)sched_id)-1].arq;
 }
 
-#endif
 
 void
 erts_init_async(void)
 {
     async = NULL;
     if (erts_async_max_threads > 0) {
-#if ERTS_USE_ASYNC_READY_Q
 	ErtsThrQInit_t qinit = ERTS_THR_Q_INIT_DEFAULT;
-#endif
 	erts_thr_opts_t thr_opts = ERTS_THR_OPTS_DEFAULT_INITER;
 	char *ptr, thr_name[16];
 	size_t tot_size = 0;
@@ -183,9 +161,7 @@ erts_init_async(void)
 
 	tot_size += ERTS_ALC_CACHE_LINE_ALIGN_SIZE(sizeof(ErtsAsyncData));
 	tot_size += sizeof(ErtsAlgndAsyncQ)*erts_async_max_threads;
-#if ERTS_USE_ASYNC_READY_Q
 	tot_size += sizeof(ErtsAlgndAsyncReadyQ)*erts_no_schedulers;
-#endif
 
 	ptr = erts_alloc_permanent_cache_aligned(ERTS_ALC_T_ASYNC_DATA,
 						 tot_size);
@@ -202,7 +178,6 @@ erts_init_async(void)
 	async->queue = (ErtsAlgndAsyncQ *) ptr;
 	ptr += sizeof(ErtsAlgndAsyncQ)*erts_async_max_threads;
 
-#if ERTS_USE_ASYNC_READY_Q
 
 	qinit.live.queue = ERTS_THR_Q_LIVE_LONG;
 	qinit.live.objects = ERTS_THR_Q_LIVE_SHORT;
@@ -222,7 +197,6 @@ erts_init_async(void)
 	    erts_thr_q_initialize(&arq->thr_q, &qinit);
 	}
 
-#endif
 
 	/* Create async threads... */
 
@@ -253,7 +227,6 @@ erts_init_async(void)
     }
 }
 
-#if ERTS_USE_ASYNC_READY_Q
 
 void *
 erts_get_async_ready_queue(Uint sched_id)
@@ -261,7 +234,6 @@ erts_get_async_ready_queue(Uint sched_id)
     return (void *) async ? async_ready_q(sched_id) : NULL;
 }
 
-#endif
 
 static ERTS_INLINE void async_add(ErtsAsync *a, ErtsAsyncQ* q)
 {
@@ -270,10 +242,8 @@ static ERTS_INLINE void async_add(ErtsAsync *a, ErtsAsyncQ* q)
 #endif
 
     if (is_internal_port(a->port)) {
-#if ERTS_USE_ASYNC_READY_Q
 	ErtsAsyncReadyQ *arq = async_ready_q(a->sched_id);
 	a->q.prep_enq = erts_thr_q_prepare_enqueue(&arq->thr_q);
-#endif
 	/* make sure the driver will stay around */
 	if (a->hndl)
 	    erts_ddll_reference_referenced_driver(a->hndl);
@@ -309,10 +279,8 @@ static ERTS_INLINE ErtsAsync *async_get(ErtsThrQ_t *q,
 					erts_tse_t *tse,
 					ErtsThrQPrepEnQ_t **prep_enq)
 {
-#if ERTS_USE_ASYNC_READY_Q
     int saved_fin_deq = 0;
     ErtsThrQFinDeQ_t fin_deq;
-#endif
 #ifdef USE_VM_PROBES
     int len;
 #endif
@@ -321,12 +289,10 @@ static ERTS_INLINE ErtsAsync *async_get(ErtsThrQ_t *q,
 	ErtsAsync *a = (ErtsAsync *) erts_thr_q_dequeue(q);
 	if (a) {
 
-#if ERTS_USE_ASYNC_READY_Q
 	    *prep_enq = a->q.prep_enq;
 	    erts_thr_q_get_finalize_dequeue_data(q, &a->q.fin_deq);
 	    if (saved_fin_deq)
 		erts_thr_q_append_finalize_dequeue_data(&a->q.fin_deq, &fin_deq);
-#endif
 #ifdef USE_LTTNG_VM_TRACEPOINTS
             if (LTTNG_ENABLED(aio_pool_get)) {
                 lttng_decl_portbuf(port_str);
@@ -354,7 +320,6 @@ static ERTS_INLINE ErtsAsync *async_get(ErtsThrQ_t *q,
 
 	    erts_tse_reset(tse);
 
-#if ERTS_USE_ASYNC_READY_Q
 	chk_fin_deq:
 	    if (erts_thr_q_get_finalize_dequeue_data(q, &tmp_fin_deq)) {
 		if (!saved_fin_deq) {
@@ -364,13 +329,11 @@ static ERTS_INLINE ErtsAsync *async_get(ErtsThrQ_t *q,
 		erts_thr_q_append_finalize_dequeue_data(&fin_deq,
 							&tmp_fin_deq);
 	    }
-#endif
 
 	    switch (erts_thr_q_inspect(q, 1)) {
 	    case ERTS_THR_Q_DIRTY:
 		break;
 	    case ERTS_THR_Q_NEED_THR_PRGR:
-#ifdef ERTS_SMP
 	    {
 		ErtsThrPrgrVal prgr = erts_thr_q_need_thr_progress(q);
 		erts_thr_progress_wakeup(NULL, prgr);
@@ -382,17 +345,14 @@ static ERTS_INLINE ErtsAsync *async_get(ErtsThrQ_t *q,
 		erts_tse_wait(tse);
 		break;
 	    }
-#endif
 	    case ERTS_THR_Q_CLEAN:
 
-#if ERTS_USE_ASYNC_READY_Q
 		if (saved_fin_deq) {
 		    if (erts_thr_q_finalize_dequeue(&fin_deq))
 			goto chk_fin_deq;
 		    else
 			saved_fin_deq = 0;
 		}
-#endif
 
 		erts_tse_wait(tse);
 		break;
@@ -408,15 +368,10 @@ static ERTS_INLINE ErtsAsync *async_get(ErtsThrQ_t *q,
 
 static ERTS_INLINE void call_async_ready(ErtsAsync *a)
 {
-#if ERTS_USE_ASYNC_READY_Q
     Port *p = erts_id2port_sflgs(a->port,
 				 NULL,
 				 0,
 				 ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP);
-#else
-    Port *p = erts_thr_id2port_sflgs(a->port,
-				     ERTS_PORT_SFLGS_INVALID_DRIVER_LOOKUP);
-#endif
     if (!p) {
 	if (a->async_free) {
             ERTS_MSACC_PUSH_AND_SET_STATE(ERTS_MSACC_STATE_PORT);
@@ -432,11 +387,7 @@ static ERTS_INLINE void call_async_ready(ErtsAsync *a)
                 ERTS_MSACC_POP_STATE();
             }
 	}
-#if ERTS_USE_ASYNC_READY_Q
 	erts_port_release(p);
-#else
-	erts_thr_port_release(p);
-#endif
     }
     if (a->pdl)
 	driver_pdl_dec_refc(a->pdl);
@@ -446,7 +397,6 @@ static ERTS_INLINE void call_async_ready(ErtsAsync *a)
 
 static ERTS_INLINE void async_reply(ErtsAsync *a, ErtsThrQPrepEnQ_t *prep_enq)
 {
-#if ERTS_USE_ASYNC_READY_Q
     ErtsAsyncReadyQ *arq;
 
 #if ERTS_ASYNC_PRINT_JOB
@@ -465,12 +415,6 @@ static ERTS_INLINE void async_reply(ErtsAsync *a, ErtsThrQPrepEnQ_t *prep_enq)
 	erts_mtx_unlock(&arq->x.data.enq_mtx);
 #endif
 
-#else /* ERTS_USE_ASYNC_READY_Q */
-
-	call_async_ready(a);
-	erts_free(ERTS_ALC_T_ASYNC, (void *) a);
-
-#endif /* ERTS_USE_ASYNC_READY_Q */
 }
 
 
@@ -486,7 +430,6 @@ static erts_tse_t *async_thread_init(ErtsAsyncQ *aq)
     erts_tse_t *tse = erts_tse_fetch();
     ERTS_DECLARE_DUMMY(Uint no);
 
-#ifdef ERTS_SMP
     ErtsThrPrgrCallbacks callbacks;
 
     callbacks.arg = (void *) tse;
@@ -495,15 +438,12 @@ static erts_tse_t *async_thread_init(ErtsAsyncQ *aq)
     callbacks.wait = NULL;
 
     erts_thr_progress_register_unmanaged_thread(&callbacks);
-#endif
 
     qinit.live.queue = ERTS_THR_Q_LIVE_LONG;
     qinit.live.objects = ERTS_THR_Q_LIVE_SHORT;
     qinit.arg = (void *) tse;
     qinit.notify = async_wakeup;
-#if ERTS_USE_ASYNC_READY_Q
     qinit.auto_finalize_dequeue = 0;
-#endif
 
     erts_thr_q_initialize(&aq->thr_q, &qinit);
 
@@ -545,12 +485,10 @@ static void *async_main(void* arg)
     return NULL;
 }
 
-#endif /* USE_THREADS */
 
 void
 erts_exit_flush_async(void)
 {
-#ifdef USE_THREADS
     int i;
     ErtsAsync a;
     a.port = NIL;
@@ -564,10 +502,8 @@ erts_exit_flush_async(void)
 	async_add(&a, async_q(i));
     for (i = 0; i < erts_async_max_threads; i++)
 	erts_thr_join(async->queue[i].aq.thr_id, NULL);
-#endif
 }
 
-#if defined(USE_THREADS) && ERTS_USE_ASYNC_READY_Q
 
 int erts_check_async_ready(void *varq)
 {
@@ -609,18 +545,15 @@ int erts_async_ready_clean(void *varq, void *val)
     case ERTS_THR_Q_DIRTY:
 	return ERTS_ASYNC_READY_DIRTY;
     case ERTS_THR_Q_NEED_THR_PRGR:
-#ifdef ERTS_SMP
 	*((ErtsThrPrgrVal *) val)
 	    = erts_thr_q_need_thr_progress(&arq->thr_q);
 	return ERTS_ASYNC_READY_NEED_THR_PRGR;
-#endif
     case ERTS_THR_Q_CLEAN:
 	break;
     }
     return ERTS_ASYNC_READY_CLEAN;
 }
 
-#endif
 
 /*
 ** Generate a fair async key prom an ErlDrvPort
@@ -658,16 +591,12 @@ long driver_async(ErlDrvPort ix, unsigned int* key,
     Port* prt;
     long id;
     unsigned int qix;
-#if ERTS_USE_ASYNC_READY_Q
     Uint sched_id;
     ERTS_MSACC_PUSH_STATE();
 
     sched_id = erts_get_scheduler_id();
     if (!sched_id)
 	sched_id = 1;
-#else
-    ERTS_MSACC_PUSH_STATE();
-#endif
 
     prt = erts_drvport2port(ix);
     if (prt == ERTS_INVALID_ERL_DRV_PORT)
@@ -677,9 +606,7 @@ long driver_async(ErlDrvPort ix, unsigned int* key,
 
     a = (ErtsAsync*) erts_alloc(ERTS_ALC_T_ASYNC, sizeof(ErtsAsync));
 
-#if ERTS_USE_ASYNC_READY_Q
     a->sched_id = sched_id;
-#endif
     a->hndl = (DE_Handle*)prt->drv_ptr->handle;
     a->port = prt->common.id;
     a->pdl = NULL;
@@ -709,7 +636,6 @@ long driver_async(ErlDrvPort ix, unsigned int* key,
 	    (*key % erts_async_max_threads) : 0;
 	*key = qix;
     }
-#ifdef USE_THREADS
     if (erts_async_max_threads > 0) {
 	if (prt->port_data_lock) {
 	    driver_pdl_inc_refc(prt->port_data_lock);
@@ -718,7 +644,6 @@ long driver_async(ErlDrvPort ix, unsigned int* key,
 	async_add(a, async_q(qix));
 	return id;
     }
-#endif
     
     ERTS_MSACC_SET_STATE_CACHED(ERTS_MSACC_STATE_PORT);
     (*a->async_invoke)(a->async_data);