libdispatch-84.5.5.tar.gz

diff --git a/src/apply.c b/src/apply.c
index 2c51eb27044f0b2cb76a9b19952df7752ca2d883..88d8066bd560f32a5fea94d60eb31651a4f16d4c 100644 (file)
--- a/src/apply.c
+++ b/src/apply.c
@@ -72,11 +72,28 @@ _dispatch_apply_serial(void *context)
 }
 
 #ifdef __BLOCKS__
 }
 
 #ifdef __BLOCKS__

+#if DISPATCH_COCOA_COMPAT
+DISPATCH_NOINLINE
+static void
+_dispatch_apply_slow(size_t iterations, dispatch_queue_t dq, void (^work)(size_t))
+{
+       struct Block_basic *bb = (void *)_dispatch_Block_copy((void *)work);
+       dispatch_apply_f(iterations, dq, bb, (void *)bb->Block_invoke);
+       Block_release(bb);
+}
+#endif
+

 void
 dispatch_apply(size_t iterations, dispatch_queue_t dq, void (^work)(size_t))
 {
 void
 dispatch_apply(size_t iterations, dispatch_queue_t dq, void (^work)(size_t))
 {

+#if DISPATCH_COCOA_COMPAT
+       // Under GC, blocks transferred to other threads must be Block_copy()ed
+       // rdar://problem/7455071
+       if (dispatch_begin_thread_4GC) {
+               return _dispatch_apply_slow(iterations, dq, work);
+       }
+#endif

        struct Block_basic *bb = (void *)work;
        struct Block_basic *bb = (void *)work;

-

        dispatch_apply_f(iterations, dq, bb, (void *)bb->Block_invoke);
 }
 #endif
        dispatch_apply_f(iterations, dq, bb, (void *)bb->Block_invoke);
 }
 #endif

diff --git a/src/queue.c b/src/queue.c
index 9111a0fde436362365ac5b0c9d7426461429fe69..231dc37f154a3c99d4f2f5b81d21484a5836f947 100644 (file)
--- a/src/queue.c
+++ b/src/queue.c
@@ -157,7 +157,10 @@ static struct dispatch_object_s *_dispatch_queue_concurrent_drain_one(dispatch_q
 static bool _dispatch_program_is_probably_callback_driven;
 
 #if DISPATCH_COCOA_COMPAT
 static bool _dispatch_program_is_probably_callback_driven;
 
 #if DISPATCH_COCOA_COMPAT

-void (*dispatch_begin_thread_4GC)(void) = dummy_function;
+// dispatch_begin_thread_4GC having non-default value triggers GC-only slow paths and
+// is checked frequently, testing against NULL is faster than comparing for equality
+// with "dummy_function"
+void (*dispatch_begin_thread_4GC)(void) = NULL;

 void (*dispatch_end_thread_4GC)(void) = dummy_function;
 void *(*_dispatch_begin_NSAutoReleasePool)(void) = (void *)dummy_function;
 void (*_dispatch_end_NSAutoReleasePool)(void *) = (void *)dummy_function;
 void (*dispatch_end_thread_4GC)(void) = dummy_function;
 void *(*_dispatch_begin_NSAutoReleasePool)(void) = (void *)dummy_function;
 void (*_dispatch_end_NSAutoReleasePool)(void *) = (void *)dummy_function;


@@ -691,8 +694,10 @@ dispatch_async_f(dispatch_queue_t dq, void *ctxt, dispatch_function_t func)
 
 struct dispatch_barrier_sync_slow2_s {
        dispatch_queue_t dbss2_dq;
 
 struct dispatch_barrier_sync_slow2_s {
        dispatch_queue_t dbss2_dq;

+#if DISPATCH_COCOA_COMPAT

        dispatch_function_t dbss2_func;
        dispatch_function_t dbss2_func;

-       dispatch_function_t dbss2_ctxt; 
+       dispatch_function_t dbss2_ctxt;
+#endif

        dispatch_semaphore_t dbss2_sema;
 };
 
        dispatch_semaphore_t dbss2_sema;
 };
 


@@ -702,12 +707,16 @@ _dispatch_barrier_sync_f_slow_invoke(void *ctxt)
        struct dispatch_barrier_sync_slow2_s *dbss2 = ctxt;
 
        dispatch_assert(dbss2->dbss2_dq == dispatch_get_current_queue());
        struct dispatch_barrier_sync_slow2_s *dbss2 = ctxt;
 
        dispatch_assert(dbss2->dbss2_dq == dispatch_get_current_queue());

-       // ALL blocks on the main queue, must be run on the main thread
-       if (dbss2->dbss2_dq == dispatch_get_main_queue()) {
+#if DISPATCH_COCOA_COMPAT
+       // When the main queue is bound to the main thread
+       if (dbss2->dbss2_dq == &_dispatch_main_q && pthread_main_np()) {

                dbss2->dbss2_func(dbss2->dbss2_ctxt);
                dbss2->dbss2_func(dbss2->dbss2_ctxt);

-       } else {
-               dispatch_suspend(dbss2->dbss2_dq);
+               dbss2->dbss2_func = NULL;
+               dispatch_semaphore_signal(dbss2->dbss2_sema);
+               return;

        }
        }

+#endif
+       dispatch_suspend(dbss2->dbss2_dq);

        dispatch_semaphore_signal(dbss2->dbss2_sema);
 }
 
        dispatch_semaphore_signal(dbss2->dbss2_sema);
 }
 


@@ -722,8 +731,10 @@ _dispatch_barrier_sync_f_slow(dispatch_queue_t dq, void *ctxt, dispatch_function
        
        struct dispatch_barrier_sync_slow2_s dbss2 = {
                .dbss2_dq = dq,
        
        struct dispatch_barrier_sync_slow2_s dbss2 = {
                .dbss2_dq = dq,

+#if DISPATCH_COCOA_COMPAT

                .dbss2_func = func,
                .dbss2_func = func,

-               .dbss2_ctxt = ctxt,             
+               .dbss2_ctxt = ctxt,
+#endif

                .dbss2_sema = _dispatch_get_thread_semaphore(),
        };
        struct dispatch_barrier_sync_slow_s {
                .dbss2_sema = _dispatch_get_thread_semaphore(),
        };
        struct dispatch_barrier_sync_slow_s {


@@ -734,33 +745,52 @@ _dispatch_barrier_sync_f_slow(dispatch_queue_t dq, void *ctxt, dispatch_function
                .dc_ctxt = &dbss2,
        };
        
                .dc_ctxt = &dbss2,
        };
        

-       dispatch_queue_t old_dq = _dispatch_thread_getspecific(dispatch_queue_key);

        _dispatch_queue_push(dq, (void *)&dbss);
        dispatch_semaphore_wait(dbss2.dbss2_sema, DISPATCH_TIME_FOREVER);
        _dispatch_queue_push(dq, (void *)&dbss);
        dispatch_semaphore_wait(dbss2.dbss2_sema, DISPATCH_TIME_FOREVER);

+       _dispatch_put_thread_semaphore(dbss2.dbss2_sema);

 
 

-       if (dq != dispatch_get_main_queue()) {
-               _dispatch_thread_setspecific(dispatch_queue_key, dq);
-               func(ctxt);
-               _dispatch_workitem_inc();
-               _dispatch_thread_setspecific(dispatch_queue_key, old_dq);
-               dispatch_resume(dq);
+#if DISPATCH_COCOA_COMPAT
+       // Main queue bound to main thread
+       if (dbss2.dbss2_func == NULL) {
+               return;

        }
        }

-       _dispatch_put_thread_semaphore(dbss2.dbss2_sema);
+#endif
+       dispatch_queue_t old_dq = _dispatch_thread_getspecific(dispatch_queue_key);
+       _dispatch_thread_setspecific(dispatch_queue_key, dq);
+       func(ctxt);
+       _dispatch_workitem_inc();
+       _dispatch_thread_setspecific(dispatch_queue_key, old_dq);
+       dispatch_resume(dq);

 }
 
 #ifdef __BLOCKS__
 }
 
 #ifdef __BLOCKS__

-void
-dispatch_barrier_sync(dispatch_queue_t dq, void (^work)(void))
+#if DISPATCH_COCOA_COMPAT
+DISPATCH_NOINLINE
+static void
+_dispatch_barrier_sync_slow(dispatch_queue_t dq, void (^work)(void))

 {
        // Blocks submitted to the main queue MUST be run on the main thread,
 {
        // Blocks submitted to the main queue MUST be run on the main thread,

-       // therefore we must Block_copy in order to notify the thread-local
+       // therefore under GC we must Block_copy in order to notify the thread-local

        // garbage collector that the objects are transferring to the main thread
        // garbage collector that the objects are transferring to the main thread

-       if (dq == dispatch_get_main_queue()) {
-               dispatch_block_t block = Block_copy(work);
+       // rdar://problem/7176237&7181849&7458685
+       if (dispatch_begin_thread_4GC) {
+               dispatch_block_t block = _dispatch_Block_copy(work);

                return dispatch_barrier_sync_f(dq, block, _dispatch_call_block_and_release);
                return dispatch_barrier_sync_f(dq, block, _dispatch_call_block_and_release);

-       }       
+       }

        struct Block_basic *bb = (void *)work;
        struct Block_basic *bb = (void *)work;

+       dispatch_barrier_sync_f(dq, work, (dispatch_function_t)bb->Block_invoke);
+}
+#endif

 
 

+void
+dispatch_barrier_sync(dispatch_queue_t dq, void (^work)(void))
+{
+#if DISPATCH_COCOA_COMPAT
+       if (slowpath(dq == &_dispatch_main_q)) {
+               return _dispatch_barrier_sync_slow(dq, work);
+       }
+#endif
+       struct Block_basic *bb = (void *)work;

        dispatch_barrier_sync_f(dq, work, (dispatch_function_t)bb->Block_invoke);
 }
 #endif
        dispatch_barrier_sync_f(dq, work, (dispatch_function_t)bb->Block_invoke);
 }
 #endif


@@ -821,9 +851,32 @@ _dispatch_sync_f_slow(dispatch_queue_t dq)
 }
 
 #ifdef __BLOCKS__
 }
 
 #ifdef __BLOCKS__

+#if DISPATCH_COCOA_COMPAT
+DISPATCH_NOINLINE
+static void
+_dispatch_sync_slow(dispatch_queue_t dq, void (^work)(void))
+{
+       // Blocks submitted to the main queue MUST be run on the main thread,
+       // therefore under GC we must Block_copy in order to notify the thread-local
+       // garbage collector that the objects are transferring to the main thread
+       // rdar://problem/7176237&7181849&7458685
+       if (dispatch_begin_thread_4GC) {
+               dispatch_block_t block = _dispatch_Block_copy(work);
+               return dispatch_sync_f(dq, block, _dispatch_call_block_and_release);
+       }
+       struct Block_basic *bb = (void *)work;
+       dispatch_sync_f(dq, work, (dispatch_function_t)bb->Block_invoke);
+}
+#endif
+

 void
 dispatch_sync(dispatch_queue_t dq, void (^work)(void))
 {
 void
 dispatch_sync(dispatch_queue_t dq, void (^work)(void))
 {

+#if DISPATCH_COCOA_COMPAT
+       if (slowpath(dq == &_dispatch_main_q)) {
+               return _dispatch_sync_slow(dq, work);
+       }
+#endif

        struct Block_basic *bb = (void *)work;
        dispatch_sync_f(dq, work, (dispatch_function_t)bb->Block_invoke);
 }
        struct Block_basic *bb = (void *)work;
        dispatch_sync_f(dq, work, (dispatch_function_t)bb->Block_invoke);
 }


@@ -1417,7 +1470,9 @@ _dispatch_worker_thread2(void *context)
 
 #if DISPATCH_COCOA_COMPAT
        // ensure that high-level memory management techniques do not leak/crash
 
 #if DISPATCH_COCOA_COMPAT
        // ensure that high-level memory management techniques do not leak/crash

-       dispatch_begin_thread_4GC();
+       if (dispatch_begin_thread_4GC) {
+               dispatch_begin_thread_4GC();
+       }

        void *pool = _dispatch_begin_NSAutoReleasePool();
 #endif
 
        void *pool = _dispatch_begin_NSAutoReleasePool();
 #endif