Пример #1
0
intptr_t
dispatch_semaphore_init(j9sem_t s, int initValue)
{
	dispatch_semaphore_t *sem = (dispatch_semaphore_t *)s;
	*sem = dispatch_semaphore_create(initValue);
	return 0;
}
Пример #2
0
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 {
Пример #3
0
Файл: gss.c Проект: B1NG0/cifs
int
smb_gss_get_cred_list(struct smb_gss_cred_list **list, gss_OID mech)
{
	struct cred_iter_ctx ctx;
	
	ctx.s = dispatch_semaphore_create(0);
	if (ctx.s == NULL)
		return ENOMEM;
	
	ctx.clist = malloc(sizeof (struct smb_gss_cred_list));
	
	if (ctx.clist == NULL) {
		dispatch_release(ctx.s);
		return ENOMEM;
	}
	
	TAILQ_INIT(ctx.clist);
	gss_iter_creds_f(NULL, 0, mech, &ctx, cred_iter);
	
	dispatch_semaphore_wait(ctx.s, DISPATCH_TIME_FOREVER);
	dispatch_release(ctx.s);
	*list = ctx.clist;
	
	return 0;
}
Пример #4
0
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 SDMMD_USBMuxListenerSend(SDMMD_USBMuxListenerRef listener, struct USBMuxPacket **packet) {
	listener->ivars.semaphore = dispatch_semaphore_create(0x0);
	SDMMD_USBMuxSend(listener->ivars.socket, *packet);
	dispatch_semaphore_wait(listener->ivars.semaphore, (*packet)->timeout);
	
	CFMutableArrayRef updateWithRemove = CFArrayCreateMutableCopy(kCFAllocatorDefault, 0x0, listener->ivars.responses);
	struct USBMuxPacket *responsePacket = NULL;
	uint32_t removeCounter = 0x0;
	for (uint32_t i = 0x0; i < CFArrayGetCount(listener->ivars.responses); i++) {
		struct USBMuxPacket *response = (struct USBMuxPacket *)CFArrayGetValueAtIndex(listener->ivars.responses, i);
		if ((*packet)->body.tag == response->body.tag) {
			responsePacket = response;
			CFArrayRemoveValueAtIndex(updateWithRemove, i-removeCounter);
			removeCounter++;
		}
	}
	CFSafeRelease(listener->ivars.responses);
	listener->ivars.responses = CFArrayCreateMutableCopy(kCFAllocatorDefault, 0x0, updateWithRemove);
	CFSafeRelease(updateWithRemove);
	USBMuxPacketRelease(*packet);
	if (!responsePacket) {
		responsePacket = (struct USBMuxPacket *)calloc(0x1, sizeof(struct USBMuxPacket));
	}
	*packet = responsePacket;
	dispatch_release(listener->ivars.semaphore);
}
Пример #6
0
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);
	});
Пример #7
0
bool SemHelper::create(int initcount)
{
	if (initcount < 0)
	{
		initcount = 0;
	}
#ifdef WIN32
	if (initcount > 64)
	{
		return false;
	}
	_hSem = CreateSemaphore(NULL, initcount, 64, NULL);
	if (_hSem == NULL)
	{
		return false;
	}
#elif defined(__APPLE__)
	_semid = dispatch_semaphore_create(initcount);
	if (!_semid)
	{
		return false;
	}
#else
	if (sem_init(&_semid, 0, initcount) != 0)
	{
		return false;
	}
	_isCreate = true;
#endif

	return true;
}
Пример #8
0
	void SignalSafeSemaphore::init()
	{
		semaphore = dispatch_semaphore_create(0);
		if (!semaphore)	// With const zero parameter this means OOM
		{
			BadAlloc::raise();
		}
	}
Пример #9
0
ResourceHandleCFURLConnectionDelegateWithOperationQueue::ResourceHandleCFURLConnectionDelegateWithOperationQueue(ResourceHandle* handle)
    : ResourceHandleCFURLConnectionDelegate(handle)
    , m_queue(dispatch_queue_create("com.apple.WebCore/CFNetwork", DISPATCH_QUEUE_SERIAL))
    , m_semaphore(dispatch_semaphore_create(0))
{
    dispatch_queue_t backgroundQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0);
    dispatch_set_target_queue(m_queue, backgroundQueue);
}
Пример #10
0
bool __Platform_Red_Threading_Semaphore_Init ( __Platform_Semaphore_t & ToInit, uint32_t ResourceCount )
{
	
	ToInit = dispatch_semaphore_create ( ResourceCount );
	
	return ToInit != NULL;
	
}
Пример #11
0
semaphore::semaphore (
    int val
)
    : d( new data )
{
    XDISPATCH_ASSERT( d.get() );
    d->native = dispatch_semaphore_create( val );
    XDISPATCH_ASSERT( d->native );
}
Пример #12
0
void snow_init_parallel(void* stack_top) {
	pthread_key_create(&state_key, finalize_thread);
	state_lock = dispatch_semaphore_create(1);
	
	static SnTask main_task;
	memset(&main_task, 0, sizeof(main_task));
	main_task.stack_top = stack_top;
	get_state()->current_task = &main_task;
}
void SDMMD_USBMuxListenerSend(SDMMD_USBMuxListenerRef listener, struct USBMuxPacket **packet)
{
	
	__block struct USBMuxPacket *block_packet = *packet;

	dispatch_sync(listener->ivars.operationQueue, ^{
		// This semaphore will be signaled when a response is received
		listener->ivars.semaphore = dispatch_semaphore_create(0);
		
		// Send the outgoing packet
		SDMMD_USBMuxSend(listener->ivars.socket, block_packet);
		
		// Wait for a response-type packet to be received
		dispatch_semaphore_wait(listener->ivars.semaphore, block_packet->timeout);
		
		CFMutableArrayRef updateWithRemove = CFArrayCreateMutableCopy(kCFAllocatorDefault, 0, listener->ivars.responses);
		
		// Search responses for a packet that matches the one sent
		struct USBMuxPacket *responsePacket = NULL;
		uint32_t removeCounter = 0;
		for (uint32_t i = 0; i < CFArrayGetCount(listener->ivars.responses); i++) {
			
			struct USBMuxPacket *response = (struct USBMuxPacket *)CFArrayGetValueAtIndex(listener->ivars.responses, i);
			if ((*packet)->body.tag == response->body.tag) {
				
				// Equal tags indicate response to request
				if (responsePacket) {
					// Found additional response, destroy old one
					USBMuxPacketRelease(responsePacket);
				}
				
				// Each matching packet is removed from the responses list
				responsePacket = response;
				CFArrayRemoveValueAtIndex(updateWithRemove, i - removeCounter);
				removeCounter++;
			}
		}
		
		if (responsePacket == NULL) {
			// Didn't find an appropriate response, initialize an empty packet to return
			responsePacket = (struct USBMuxPacket *)calloc(1, sizeof(struct USBMuxPacket));
		}
		
		CFSafeRelease(listener->ivars.responses);
		listener->ivars.responses = CFArrayCreateMutableCopy(kCFAllocatorDefault, 0, updateWithRemove);
		CFSafeRelease(updateWithRemove);
		
		// Destroy sent packet
		USBMuxPacketRelease(block_packet);
		
		// Return response packet to caller
		block_packet = responsePacket;
		
		// Discard "waiting for response" semaphore
		dispatch_release(listener->ivars.semaphore);
	});
Пример #14
0
Файл: gss.c Проект: B1NG0/cifs
static int
smb_acquire_cred(const char *user, const char *domain, const char *password, 
				 gss_OID mech, void **gssCreds)
{
	gss_auth_identity_desc identity;
	struct smb_gss_cred_ctx aq_cred_ctx;
	uint32_t maj = !GSS_S_COMPLETE;

	if (password == NULL || user == NULL || *user == '\0') 
		return 0;
		
	identity.type = GSS_AUTH_IDENTITY_TYPE_1;
	identity.flags = 0;
	identity.username = strdup(user);
	identity.realm = strdup(domain ? domain : "");
	identity.password = strdup(password);
	identity.credentialsRef = NULL;
	
	if (identity.username == NULL ||
	    identity.realm == NULL || 
	    identity.password == NULL)
	    goto out;
	
	aq_cred_ctx.sem = dispatch_semaphore_create(0);
	if (aq_cred_ctx.sem == NULL)
		goto out;

	maj = gss_acquire_cred_ex_f(NULL,
				    GSS_C_NO_NAME,
				    0,
				    GSS_C_INDEFINITE,
				    mech,
				    GSS_C_INITIATE,
				    &identity,
				    &aq_cred_ctx,
				    acquire_cred_complete);
	
	if (maj == GSS_S_COMPLETE) {
		dispatch_semaphore_wait(aq_cred_ctx.sem, DISPATCH_TIME_FOREVER);
		maj = aq_cred_ctx.maj;
		*gssCreds = aq_cred_ctx.creds;
	}
	
	if (maj != GSS_S_COMPLETE)
		smb_log_info("Acquiring NTLM creds for %s\%s failed. GSS returned %d",
			ASL_LEVEL_INFO, domain, user, maj);

	dispatch_release(aq_cred_ctx.sem);
out:
	free(identity.username);
	free(identity.realm);
	free(identity.password);
	
	return (maj == GSS_S_COMPLETE);
}
Пример #15
0
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);
    });
Пример #16
0
static VALUE
rb_semaphore_init(VALUE self, SEL sel, VALUE value)
{
    dispatch_semaphore_t s = dispatch_semaphore_create(NUM2LONG(value));
    if (s == NULL) {
    	rb_raise(rb_eArgError, "Can't create semaphore based on value `%ld'",
    		NUM2LONG(value));
    }
    RSemaphore(self)->sem = s;
    RSemaphore(self)->count = NUM2LONG(value);
    return self;
}
Пример #17
0
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);
  });
Пример #18
0
// CONSTRUCTOR
//------------------------------------------------------------------------------
Semaphore::Semaphore()
{
    #if defined( __WINDOWS__ )
        m_Semaphore = CreateSemaphore( nullptr, 0, 0x7FFFFFFF, nullptr );
        ASSERT( m_Semaphore );
    #elif defined( __APPLE__ )
        m_Semaphore = dispatch_semaphore_create(0);
        ASSERT( m_Semaphore );
    #elif defined( __LINUX__ )
        VERIFY( sem_init( &m_Semaphore, 0, 0 ) == 0 );
    #endif
}
Пример #19
0
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);
    });
Пример #20
0
int main() {
  fprintf(stderr, "Hello world.\n");
  dispatch_semaphore_t done = dispatch_semaphore_create(0);
  barrier_init(&barrier, 2);

  dispatch_queue_t q = dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);
  dispatch_queue_t bgq = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);

  dispatch_async(bgq, ^{
    dispatch_sync(q, ^{
      global = 42;
    });
    barrier_wait(&barrier);
  });
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);
	});
Пример #23
0
heim_isemaphore
heim_ipc_semaphore_create(long value)
{
#ifdef HAVE_GCD
    return (heim_isemaphore)dispatch_semaphore_create(value);
#elif !defined(ENABLE_PTHREAD_SUPPORT)
    heim_assert(0, "no semaphore support w/o pthreads");
    return NULL;
#else
    heim_isemaphore s = malloc(sizeof(*s));
    if (s == NULL)
	return NULL;
    HEIMDAL_MUTEX_init(&s->mutex);
    pthread_cond_init(&s->cond, NULL);
    s->counter = value;
    return s;
#endif
}
Пример #24
0
static OSStatus sendTSARequestWithXPC(const unsigned char *tsaReq, size_t tsaReqLength, const unsigned char *tsaURL, unsigned char **tsaResp, size_t *tsaRespLength)
{
    __block OSStatus result = noErr;
    int timeoutInSeconds = 15;
    extern xpc_object_t xpc_create_with_format(const char * format, ...);

	dispatch_queue_t xpc_queue = dispatch_queue_create("com.apple.security.XPCTimeStampingService", DISPATCH_QUEUE_SERIAL);
    __block dispatch_semaphore_t waitSemaphore = dispatch_semaphore_create(0);
    dispatch_time_t finishTime = dispatch_time(DISPATCH_TIME_NOW, timeoutInSeconds * NSEC_PER_SEC);

    xpc_connection_t con = xpc_connection_create("com.apple.security.XPCTimeStampingService", xpc_queue);

    xpc_connection_set_event_handler(con, ^(xpc_object_t event) {
        xpc_type_t xtype = xpc_get_type(event);
        if (XPC_TYPE_ERROR == xtype)
        {    tsaDebug("default: connection error: %s\n", xpc_dictionary_get_string(event, XPC_ERROR_KEY_DESCRIPTION)); }
        else
         {   tsaDebug("default: unexpected connection event %p\n", event); }
    });
Пример #25
0
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);
  });
int main(int argc, const char *argv[]) {
  done = dispatch_semaphore_create(0);

  dispatch_queue_t queue =
      dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);

  dispatch_source_t source =
      dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGHUP, 0, queue);

  global = 42;

  dispatch_source_set_registration_handler_f(source, handler);

  dispatch_resume(source);

  dispatch_semaphore_wait(done, DISPATCH_TIME_FOREVER);

  return 0;
}
Пример #27
0
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;
}
Пример #28
0
Error Sem::create(KDuint value, Sem **returnValue)
{
    const long lvalue = static_cast<long>(value);
    if (lvalue < 0)
    {
        *returnValue = nullptr;
        return Error(KD_EINVAL);
    }

    const dispatch_semaphore_t dispatch = dispatch_semaphore_create(lvalue);
    if (dispatch == nullptr)
    {
        *returnValue = nullptr;
        return Error(KD_ENOSPC);
    }

    Sem *sem = new Sem;
    sem->mNativeSem.dispatch = dispatch;
    sem->mNativeSem.value = lvalue;
    *returnValue = sem;
    return Error(0);
}
Пример #29
0
void OSXMakeQueue(platform_work_queue* Queue, uint32 ThreadCount)
{
	Queue->CompletionGoal = 0;
	Queue->CompletionCount = 0;

	Queue->NextEntryToWrite = 0;
	Queue->NextEntryToRead = 0;

	Queue->SemaphoreHandle = dispatch_semaphore_create(0);

	for (uint32 ThreadIndex = 0;
		 ThreadIndex < ThreadCount;
		 ++ThreadIndex)
	{
		pthread_t		ThreadId;

		int r = pthread_create(&ThreadId, NULL, OSXQueueThreadProc, Queue);
		if (r != 0)
		{
			printf("Error creating thread %d\n", ThreadIndex);
		}
	}
}
Пример #30
0
 * @file
 * vuo.test.delay node implementation.
 *
 * @copyright Copyright © 2012–2014 Kosada Incorporated.
 * This code may be modified and distributed under the terms of the GNU Lesser General Public License (LGPL) version 2 or later.
 * For more information, see http://vuo.org/license.
 */

#include "node.h"

#include <dispatch/dispatch.h>

VuoModuleMetadata({
					 "title" : "Delay",
					 "description" : "",
					 "version" : "1.0.0",
					 "node": {
						 "isInterface" : false
					 }
				 });

void nodeEvent
(
		VuoInputData(VuoReal, {"default":1,"suggestedMin":0,"suggestedStep":0.1}) seconds,
		VuoOutputEvent() event
)
{
	dispatch_semaphore_t temporaryDeadlock = dispatch_semaphore_create(0);
	dispatch_semaphore_wait(temporaryDeadlock, dispatch_time(DISPATCH_TIME_NOW, seconds * NSEC_PER_SEC));
}