CAMLprim value
caml_init_vmnet(value v_mode)
{
CAMLparam1(v_mode);
CAMLlocal3(v_iface_ref,v_res,v_mac);
xpc_object_t interface_desc = xpc_dictionary_create(NULL, NULL, 0);
xpc_dictionary_set_uint64(interface_desc, vmnet_operation_mode_key, Int_val(v_mode));
uuid_t uuid;
uuid_generate_random(uuid);
xpc_dictionary_set_uuid(interface_desc, vmnet_interface_id_key, uuid);
__block interface_ref iface = NULL;
__block vmnet_return_t iface_status = 0;
__block unsigned char *mac = malloc(6);
if (!mac) caml_raise_out_of_memory ();
__block unsigned int mtu = 0;
__block unsigned int max_packet_size = 0;
dispatch_queue_t if_create_q = dispatch_queue_create("org.openmirage.vmnet.create", DISPATCH_QUEUE_SERIAL);
dispatch_semaphore_t iface_created = dispatch_semaphore_create(0);
iface = vmnet_start_interface(interface_desc, if_create_q,
^(vmnet_return_t status, xpc_object_t interface_param) {
iface_status = status;
if (status != VMNET_SUCCESS || !interface_param) {
dispatch_semaphore_signal(iface_created);
return;
}
//printf("mac desc: %s\n", xpc_copy_description(xpc_dictionary_get_value(interface_param, vmnet_mac_address_key)));
const char *macStr = xpc_dictionary_get_string(interface_param, vmnet_mac_address_key);
unsigned char lmac[6];
if (sscanf(macStr, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", &lmac[0], &lmac[1], &lmac[2], &lmac[3], &lmac[4], &lmac[5]) != 6)
errx(1, "Unexpected MAC address received from vmnet");
memcpy(mac, lmac, 6);
mtu = xpc_dictionary_get_uint64(interface_param, vmnet_mtu_key);
max_packet_size = xpc_dictionary_get_uint64(interface_param, vmnet_max_packet_size_key);
dispatch_semaphore_signal(iface_created);
});
void OSXAddEntry(platform_work_queue* Queue, platform_work_queue_callback* Callback, void* Data)
{
// TODO(casey): Switch to InterlockedCompareExchange eventually
// so that any thread can add?
uint32 NewNextEntryToWrite = (Queue->NextEntryToWrite + 1) % ArrayCount(Queue->Entries);
Assert(NewNextEntryToWrite != Queue->NextEntryToRead);
platform_work_queue_entry *Entry = Queue->Entries + Queue->NextEntryToWrite;
Entry->Callback = Callback;
Entry->Data = Data;
++Queue->CompletionGoal;
OSMemoryBarrier();
// Not needed: _mm_sfence();
Queue->NextEntryToWrite = NewNextEntryToWrite;
dispatch_semaphore_signal(Queue->SemaphoreHandle);
#if 0
int r = dispatch_semaphore_signal(Queue->SemaphoreHandle);
if (r > 0)
{
printf(" dispatch_semaphore_signal: A thread was woken\n");
}
else
{
printf(" dispatch_semaphore_signal: No thread was woken\n");
}
#endif
}
static void finalize_thread(void* _state) {
SnDispatchThreadState* s = (SnDispatchThreadState*)_state;
dispatch_semaphore_signal(s->gc_barrier); // when finalizing a thread during gc, we don't want to wait for this.
dispatch_semaphore_wait(state_lock, DISPATCH_TIME_FOREVER);
if (s->next) s->next->previous = s->previous;
if (s->previous) s->previous->next = s->next;
state = s->next;
dispatch_semaphore_signal(state_lock);
dispatch_release(s->gc_barrier);
snow_free(s);
}
void *consumerFunc(void * arg) // 消费者线程
{
while(true)
{
dispatch_semaphore_wait(full, DISPATCH_TIME_FOREVER);
dispatch_semaphore_wait(mutex, DISPATCH_TIME_FOREVER);
remove_item();
print_items();
dispatch_semaphore_signal(mutex);
dispatch_semaphore_signal(empty);
sleep(5);
}
}
static void
rb_semaphore_finalize(void *rcv, SEL sel)
{
if (RSemaphore(rcv)->sem != NULL) {
while (dispatch_semaphore_signal(RSemaphore(rcv)->sem) != 0) {}
while (--RSemaphore(rcv)->count >= 0) {
dispatch_semaphore_signal(RSemaphore(rcv)->sem);
}
dispatch_release(RSemaphore(rcv)->sem);
}
if (rb_semaphore_finalize_super != NULL) {
((void(*)(void *, SEL))rb_semaphore_finalize_super)(rcv, sel);
}
}
void *producerFunc(void *arg) // 生产者线程
{
int item;
while(true)
{
dispatch_semaphore_wait(empty, DISPATCH_TIME_FOREVER);
dispatch_semaphore_wait(mutex, DISPATCH_TIME_FOREVER);
item = product_NO++;
insert_item(item);
print_items();
dispatch_semaphore_signal(mutex);
dispatch_semaphore_signal(full);
sleep(3);
}
}
static void
trigger_jobs(void)
{
time_t now = time(NULL);
while (1) {
struct heim_event_data *e = rk_UNCONST(heap_head(timer_heap));
if (e != NULL && e->t < now) {
heap_remove_head(timer_heap);
e->hptr = HEAP_INVALID_PTR;
/* if its already running, lets retry 10s from now */
if (e->flags & RUNNING) {
e->t = now + 10;
heap_insert(timer_heap, e, &e->hptr);
continue;
}
e->flags |= RUNNING;
_heim_ipc_suspend_timer();
dispatch_async(timer_job_q, ^{
e->callback(e, e->ctx);
dispatch_async(timer_sync_q, ^{
e->flags &= ~RUNNING;
if (e->running)
dispatch_semaphore_signal(e->running);
_heim_ipc_restart_timer();
});
});
char *
Digest_File(CCDigestAlg algorithm, const char *filename, char *buf)
{
int fd;
__block CCDigestCtx ctx;
dispatch_queue_t queue;
dispatch_semaphore_t sema;
dispatch_io_t io;
__block int s_error = 0;
/* dispatch_io_create_with_path requires an absolute path */
fd = open(filename, O_RDONLY);
if (fd < 0) {
return NULL;
}
(void)fcntl(fd, F_NOCACHE, 1);
(void)osx_assumes_zero(CCDigestInit(algorithm, &ctx));
queue = dispatch_queue_create("com.apple.mtree.io", NULL);
osx_assert(queue);
sema = dispatch_semaphore_create(0);
osx_assert(sema);
io = dispatch_io_create(DISPATCH_IO_STREAM, fd, queue, ^(int error) {
if (error != 0) {
s_error = error;
}
(void)close(fd);
(void)dispatch_semaphore_signal(sema);
});
void
RTMPSession::streamStatusChanged(StreamStatus_t status)
{
if(status & kStreamStatusConnected && m_state < kClientStateConnected) {
setClientState(kClientStateConnected);
}
if(status & kStreamStatusReadBufferHasBytes) {
dataReceived();
}
if(status & kStreamStatusWriteBufferHasSpace) {
if(m_state < kClientStateHandshakeComplete) {
handshake();
} else {
#ifdef __APPLE__
dispatch_semaphore_signal(m_networkWaitSemaphore);
#else
m_networkMutex.unlock();
m_networkCond.notify_one();
#endif
}
}
if(status & kStreamStatusEndStream) {
setClientState(kClientStateNotConnected);
}
if(status & kStreamStatusErrorEncountered) {
setClientState(kClientStateError);
}
}
int main (int argc, const char * argv[]) {
dispatch_group_t mg = dispatch_group_create();
dispatch_semaphore_t ds;
__block int numRunning = 0;
int qWidth = 5;
int numWorkBlocks = 100;
if (argc >= 2) {
qWidth = atoi(argv[1]); // use the command 1st line parameter as the queue width
if (qWidth==0) qWidth=1; // protect against bad values
}
if (argc >=3) {
numWorkBlocks = atoi(argv[2]); // use the 2nd command line parameter as the queue width
if (numWorkBlocks==0) numWorkBlocks=1; // protect against bad values
}
printf("Starting dispatch semaphore test to simulate a %d wide dispatch queue\n", qWidth );
ds = dispatch_semaphore_create(qWidth);
int i;
for (i=0; i<numWorkBlocks; i++) {
// synchronize the whole shebang every 25 work units...
if (i % 25 == 24) {
dispatch_group_async(mg,dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT,0), ^{
// wait for all pending work units to finish up...
for (int x=0; x<qWidth; x++) dispatch_semaphore_wait(ds, DISPATCH_TIME_FOREVER);
// do the thing that is critical here
printf("doing something critical...while %d work units are running \n",numRunning);
// and let work continue unimpeeded
for (int x=0; x<qWidth; x++) dispatch_semaphore_signal(ds);
});
} else {
void __Platform_Red_Threading_Semaphore_Post ( __Platform_Semaphore_t & Target, uint32_t PostCount )
{
for ( uint32_t I = 0; I < PostCount; I ++ )
dispatch_semaphore_signal ( Target );
}
void ResourceHandleCFURLConnectionDelegateWithOperationQueue::releaseHandle()
{
ResourceHandleCFURLConnectionDelegate::releaseHandle();
m_requestResult = nullptr;
m_cachedResponseResult = nullptr;
m_boolResult = false;
dispatch_semaphore_signal(m_semaphore);
}
static void
cred_iter(void *ctx, gss_OID moid, gss_cred_id_t cred)
{
struct cred_iter_ctx *context = (struct cred_iter_ctx *)ctx;
if (cred == GSS_C_NO_CREDENTIAL) {
dispatch_semaphore_signal(context->s);
return;
}
smb_gss_add_cred(context->clist, moid, cred);
}
static int
vmnet_get_mac_address_from_uuid(char *guest_uuid_str) {
/*
* from vmn_create() in https://github.com/mist64/xhyve/blob/master/src/pci_virtio_vmnet.c
*/
xpc_object_t interface_desc;
uuid_t uuid;
__block interface_ref iface;
__block vmnet_return_t iface_status;
dispatch_semaphore_t iface_created;
dispatch_queue_t if_create_q;
uint32_t uuid_status;
interface_desc = xpc_dictionary_create(NULL, NULL, 0);
xpc_dictionary_set_uint64(interface_desc, vmnet_operation_mode_key, VMNET_SHARED_MODE);
uuid_from_string(guest_uuid_str, &uuid, &uuid_status);
if (uuid_status != uuid_s_ok) {
fprintf(stderr, "Invalid UUID\n");
return -1;
}
xpc_dictionary_set_uuid(interface_desc, vmnet_interface_id_key, uuid);
iface = NULL;
iface_status = 0;
if_create_q = dispatch_queue_create("org.xhyve.vmnet.create", DISPATCH_QUEUE_SERIAL);
iface_created = dispatch_semaphore_create(0);
iface = vmnet_start_interface(interface_desc, if_create_q,
^(vmnet_return_t status, xpc_object_t interface_param)
{
iface_status = status;
if (status != VMNET_SUCCESS || !interface_param) {
dispatch_semaphore_signal(iface_created);
return;
}
printf("%s\n", xpc_dictionary_get_string(interface_param, vmnet_mac_address_key));
dispatch_semaphore_signal(iface_created);
});
// Signal
//------------------------------------------------------------------------------
void Semaphore::Signal()
{
#if defined( __WINDOWS__ )
VERIFY( ReleaseSemaphore( m_Semaphore, 1, nullptr ) );
#elif defined( __APPLE__ )
dispatch_semaphore_signal( m_Semaphore );
#elif defined( __LINUX__ )
VERIFY( sem_post( &m_Semaphore ) == 0 );
#endif
}
static void *
spinning_thread(void *semp)
{
T_QUIET;
T_ASSERT_NOTNULL(semp, "semaphore passed to thread should not be NULL");
dispatch_semaphore_signal(*(dispatch_semaphore_t *)semp);
while (running_threads);
return NULL;
}
int
OSMemoryNotificationTimedWait(OSMemoryNotificationRef note, OSMemoryNotificationLevel *level, const struct timeval *abstime)
{
dispatch_semaphore_t sema = dispatch_semaphore_create(0);
dispatch_retain(sema);
dispatch_source_t memoryNotificationSource = dispatch_source_create(DISPATCH_SOURCE_TYPE_VM, 0, DISPATCH_VM_PRESSURE, dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0));
dispatch_source_set_event_handler(memoryNotificationSource, ^{
dispatch_semaphore_signal(sema);
dispatch_release(sema);
});
bool SemHelper::post()
{
#ifdef WIN32
return ReleaseSemaphore(_hSem, 1, NULL) ? true : false;
#elif defined(__APPLE__)
return dispatch_semaphore_signal(_semid) == 0;
#else
return (sem_post(&_semid) == 0);
#endif
}
static void
acquire_cred_complete(void *ctx, OM_uint32 maj, gss_status_id_t status __unused,
gss_cred_id_t creds, gss_OID_set oids, OM_uint32 time_rec __unused)
{
uint32_t min;
struct smb_gss_cred_ctx *aq_cred_ctx = ctx;
gss_release_oid_set(&min, &oids);
aq_cred_ctx->creds = creds;
aq_cred_ctx->maj = maj;
dispatch_semaphore_signal(aq_cred_ctx->sem);
}
int main(int argc, const char *argv[]) {
fprintf(stderr, "start\n");
done = dispatch_semaphore_create(0);
dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
my_global = 10;
dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_MSEC)), q, ^{
my_global = 42;
dispatch_semaphore_signal(done);
});
static bool clearAllKVS(CFErrorRef *error)
{
__block bool result = false;
const uint64_t maxTimeToWaitInSeconds = 30ull * NSEC_PER_SEC;
dispatch_queue_t processQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
dispatch_semaphore_t waitSemaphore = dispatch_semaphore_create(0);
dispatch_time_t finishTime = dispatch_time(DISPATCH_TIME_NOW, maxTimeToWaitInSeconds);
SOSCloudKeychainClearAll(processQueue, ^(CFDictionaryRef returnedValues, CFErrorRef cerror)
{
result = (cerror != NULL);
dispatch_semaphore_signal(waitSemaphore);
});
void dispatch_semaphore_blocks()
{
static size_t total;
dispatch_semaphore_t dsema;
MU_BEGIN_TEST(dispatch_semaphore_blocks);
dsema = dispatch_semaphore_create(1);
MU_ASSERT_NOT_NULL(dsema);
dispatch_apply(LAPS, dispatch_queue_create(0,0), ^(size_t idx) {
dispatch_semaphore_wait(dsema, DISPATCH_TIME_FOREVER);
total++;
dispatch_semaphore_signal(dsema);
});
int
main(void)
{
static long total;
dispatch_semaphore_t dsema;
dispatch_test_start("Dispatch Semaphore");
dsema = dispatch_semaphore_create(1);
assert(dsema);
dispatch_apply(LAPS, dispatch_get_global_queue(0, 0), ^(size_t idx __attribute__((unused))) {
dispatch_semaphore_wait(dsema, DISPATCH_TIME_FOREVER);
total++;
dispatch_semaphore_signal(dsema);
});
long
heim_ipc_semaphore_signal(heim_isemaphore s)
{
#ifdef HAVE_GCD
return dispatch_semaphore_signal((dispatch_semaphore_t)s);
#elif !defined(ENABLE_PTHREAD_SUPPORT)
heim_assert(0, "no semaphore support w/o pthreads");
return EINVAL;
#else
int wakeup;
HEIMDAL_MUTEX_lock(&s->mutex);
wakeup = (++s->counter == 0) ;
HEIMDAL_MUTEX_unlock(&s->mutex);
if (wakeup)
pthread_cond_signal(&s->cond);
return 0;
#endif
}
/*
* pj_sem_post()
*/
PJ_DEF(pj_status_t) pj_sem_post(pj_sem_t *sem)
{
#if PJ_HAS_THREADS
int result;
PJ_LOG(6, (sem->obj_name, "Semaphore released by thread %s",
pj_thread_this(sem->inst_id)->obj_name));
#if defined(PJ_DARWINOS) && PJ_DARWINOS!=0
result = dispatch_semaphore_signal(sem->sem);
#else
result = sem_post( sem->sem );
#endif
if (result == 0)
return PJ_SUCCESS;
else
return PJ_RETURN_OS_ERROR(pj_get_native_os_error());
#else
pj_assert( sem == (pj_sem_t*) 1);
return PJ_SUCCESS;
#endif
}
static SnDispatchThreadState* init_thread() {
ASSERT(pthread_getspecific(state_key) == NULL);
SnDispatchThreadState* s = (SnDispatchThreadState*)snow_malloc(sizeof(SnDispatchThreadState));
s->current_task = NULL;
s->gc_barrier = dispatch_semaphore_create(0); // starts locked
s->previous = NULL;
// prepend this state to the list of thread states
dispatch_semaphore_wait(state_lock, DISPATCH_TIME_FOREVER);
s->next = state;
if (s->next) {
ASSERT(s->next->previous == NULL);
s->next->previous = s;
}
state = s;
dispatch_semaphore_signal(state_lock);
pthread_setspecific(state_key, s);
return s;
}
static void
_dispatch_apply2(void *_ctxt)
{
struct dispatch_apply_s *da = _ctxt;
size_t const iter = da->da_iterations;
dispatch_function_apply_t func = da->da_func;
void *const ctxt = da->da_ctxt;
size_t idx;
_dispatch_workitem_dec(); // this unit executes many items
// Striding is the responsibility of the caller.
while (fastpath((idx = dispatch_atomic_inc((intptr_t*)&da->da_index) - 1) < iter)) {
func(ctxt, idx);
_dispatch_workitem_inc();
}
if (dispatch_atomic_dec((intptr_t*)&da->da_thr_cnt) == 0) {
dispatch_semaphore_signal(da->da_sema);
}
}
/*
* 'cups_gss_acquire()' - Kerberos credentials callback.
*/
static void
cups_gss_acquire(
void *ctx, /* I - Caller context */
OM_uint32 major, /* I - Major error code */
gss_status_id_t status, /* I - Status (unused) */
gss_cred_id_t creds, /* I - Credentials (if any) */
gss_OID_set oids, /* I - Mechanism OIDs (unused) */
OM_uint32 time_rec) /* I - Timestamp (unused) */
{
uint32_t min; /* Minor error code */
_cups_gss_acquire_t *data; /* Callback data */
(void)status;
(void)time_rec;
data = (_cups_gss_acquire_t *)ctx;
data->major = major;
data->creds = creds;
gss_release_oid_set(&min, &oids);
dispatch_semaphore_signal(data->sem);
}
int gbDB_IncDecrementWithSemaphore(int* x,
dispatch_semaphore_t sema,
const bool isInc,
const bool isDec)
{
int retVal = -1;
dispatch_semaphore_wait(sema, DISPATCH_TIME_FOREVER);
if (isInc)
{
*x = *x + 1;
}//if
else if (isDec)
{
*x = *x - 1;
}//else if
retVal = *x;
dispatch_semaphore_signal(sema);
return retVal;
}//gbDB_IncDecrementWithSemaphore
/*
* call-seq:
* sema.signal => true or false
*
* Signals the semaphore to wake up any waiting threads
*
* Returns true if no thread is waiting, false otherwise
*
* gcdq = Dispatch::Queue.new('doc')
* sema = Dispatch::Semaphore.new(0)
* gcdq.async { sleep 0.1; sema.signal } #=> false
* sema.wait
*
*/
static VALUE
rb_semaphore_signal(VALUE self, SEL sel)
{
return dispatch_semaphore_signal(RSemaphore(self)->sem) == 0
? Qtrue : Qfalse;
}