NTSTATUS SMBRetainServer( SMBHANDLE inConnection) { OSAtomicIncrement32(&inConnection->refcount); return STATUS_SUCCESS; }
END_AS_NAMESPACE #include <libkern/OSAtomic.h> BEGIN_AS_NAMESPACE asDWORD asCAtomic::atomicInc() { return OSAtomicIncrement32((int32_t*)&value); }
END_AS_NAMESPACE #include <libkern/OSAtomic.h> BEGIN_AS_NAMESPACE int asAtomicInc(int &value) { return OSAtomicIncrement32((int32_t*)&value); }
void BufferManager::CopyAudioDataToFFTInputBuffer( Float32* inData, UInt32 numFrames ) { UInt32 framesToCopy = min(numFrames, mFFTInputBufferLen - mFFTInputBufferFrameIndex); memcpy(mFFTInputBuffer + mFFTInputBufferFrameIndex, inData, framesToCopy * sizeof(Float32)); mFFTInputBufferFrameIndex += framesToCopy * sizeof(Float32); if (mFFTInputBufferFrameIndex >= mFFTInputBufferLen) { OSAtomicIncrement32(&mHasNewFFTData); OSAtomicDecrement32(&mNeedsNewFFTData); } }
unsigned Atomic::operator++() { #if defined(_OPENTHREADS_ATOMIC_USE_GCC_BUILTINS) return __sync_add_and_fetch(&_value, 1); #elif defined(_OPENTHREADS_ATOMIC_USE_WIN32_INTERLOCKED) return InterlockedIncrement(&_value); #elif defined(_OPENTHREADS_ATOMIC_USE_BSD_ATOMIC) return OSAtomicIncrement32(&_value); #else # error This implementation should happen inline in the include file #endif }
void BufferManager::CopyAudioDataToBuffer( Float32* inData, UInt32 NewNumSamples ) { if (inData == NULL) return; for (UInt32 i=0; i<NewNumSamples; i++) { if (i + _CurDataIdx >= _BufferLen) _CurDataIdx = -i; _AudioDataBuffer[i + _CurDataIdx] = inData[i]; } _CurDataIdx += NewNumSamples; // The following segment of codes assume that GetFFTOuput() is being continuously called! if (_FFTStartIdx < _FFTEndIdx) { if (_FFTEndIdx < _CurDataIdx && NeedsNewFFTData()) { //printf("_CurDataIdx: %ld\n", _CurDataIdx); OSAtomicIncrement32(&_HasNewFFTData); OSAtomicDecrement32(&_NeedsNewFFTData); } } else if (_FFTEndIdx < _FFTStartIdx) { if (_FFTEndIdx < _CurDataIdx && _CurDataIdx < _FFTStartIdx && NeedsNewFFTData()) { //printf("_CurDataIdx: %ld\n", _CurDataIdx); OSAtomicIncrement32(&_HasNewFFTData); OSAtomicDecrement32(&_NeedsNewFFTData); } } else printf("BufferManager::CopyAudioDataToBuffer() - this code should never execute!"); }
void *client(void *arg) { channel_t channel = (channel_t)arg; uint32_t major_stat; uint32_t minor_stat; uint32_t rflags; uint32_t inout_gssd_flags; gssd_cred cred_handle = (gssd_cred) (uintptr_t)GSS_C_NO_CREDENTIAL; gssd_ctx gss_context = (gssd_ctx) (uintptr_t)GSS_C_NO_CONTEXT; kern_return_t kr; int gss_error = 0; int retry_count = 0; char display_name[128]; do { if (read_channel(1, channel)) { Log("Bad read from server\n"); return (NULL); } if (verbose) Debug("Calling mach_gss_init_sec_context from %p\n", (void *) pthread_self()); deallocate(channel->ctoken, channel->ctokenCnt); channel->ctoken = (gssd_byte_buffer)GSS_C_NO_BUFFER; channel->ctokenCnt = 0; retry: switch (version) { case 0: case 1: kr = mach_gss_init_sec_context( client_mp, mech, channel->stoken, channel->stokenCnt, uid, principal, svcname, flags, gssd_flags, &gss_context, &cred_handle, &rflags, &channel->clnt_skey, &channel->clnt_skeyCnt, &channel->ctoken, &channel->ctokenCnt, &major_stat, &minor_stat); break; case 2: inout_gssd_flags = gssd_flags; kr = mach_gss_init_sec_context_v2( client_mp, mech, channel->stoken, channel->stokenCnt, uid, clientp.nt, clientp.name, clientp.len, targetp.nt, targetp.name, targetp.len, flags, &inout_gssd_flags, &gss_context, &cred_handle, &rflags, &channel->clnt_skey, &channel->clnt_skeyCnt, &channel->ctoken, &channel->ctokenCnt, display_name, &major_stat, &minor_stat); if (verbose && kr == KERN_SUCCESS && major_stat == GSS_S_COMPLETE) Debug("Got client identity of '%s'\n", display_name); break; default: Log("Unsupported version %d\n", version); exit(1); break; } if (kr != KERN_SUCCESS) { OSAtomicIncrement32(&server_errors); Log("gsstest client: %s\n", mach_error_string(kr)); if (exitonerror) exit(1); if (kr == MIG_SERVER_DIED) { OSAtomicIncrement32(&server_deaths); if (gss_context == (uint32_t)(uintptr_t)GSS_C_NO_CONTEXT && retry_count < max_retries) { retry_count++; goto retry; } } channel->failure = 1; write_channel(1, channel); return (NULL); } gss_error = (major_stat != GSS_S_COMPLETE && major_stat != GSS_S_CONTINUE_NEEDED); if (verbose > 1) { Debug("\tcred = 0x%0x\n", (int) cred_handle); Debug("\tclnt_gss_context = 0x%0x\n", (int) gss_context); Debug("\ttokenCnt = %d\n", (int) channel->ctokenCnt); if (verbose > 2) HexDump((char *) channel->ctoken, (uint32_t) channel->ctokenCnt); } channel->failure = gss_error; write_channel(1, channel); } while (major_stat == GSS_S_CONTINUE_NEEDED); if (gss_error) { OSAtomicIncrement32(&gss_init_errors); Log("mach_gss_int_sec_context: %#K %#k\n", major_stat, mechtab[mech], minor_stat); } close_channel(1, channel); return (NULL); }
#include <stdio.h> #include <CoreFoundation/CoreFoundation.h> #ifdef __APPLE__ #include <libkern/OSAtomic.h> #endif #include <bsdtests.h> #include "dispatch_test.h" const int32_t final = 10; static volatile int32_t count; static void work(void* ctxt __attribute__((unused))) { int32_t c = OSAtomicIncrement32(&count); if (c < final-1) { dispatch_async_f(dispatch_get_main_queue(), NULL, work); CFRunLoopPerformBlock(CFRunLoopGetMain(), kCFRunLoopDefaultMode, ^{ fprintf(stderr, "CFRunLoopPerformBlock %d\n", c); test_long_less_than("CFRunLoopPerformBlock", count, final); }); } } int main(void) { dispatch_test_start("Dispatch CF main queue"); // <rdar://problem/7760523> dispatch_async_f(dispatch_get_main_queue(), NULL, work); dispatch_async_f(dispatch_get_main_queue(), NULL, work);
long InterlockedIncrement(long volatile* Addend) { return OSAtomicIncrement32(reinterpret_cast<int32_t volatile*>(Addend)); }
ULONG STDMETHODCALLTYPE DeckLink::AddRef(void) { return OSAtomicIncrement32(&referenceCount); };
static inline CFNotificationObserver *CFNotificationObserverRetain(CFAllocatorRef allocator, CFNotificationObserver *observer) { observer->retainCount = OSAtomicIncrement32(&observer->retainCount); return observer; }
inline void AtomicIncrement(volatile esint32* i) { OSAtomicIncrement32(i); }
template <typename T> static T inc(volatile T*scalar) { return (T)OSAtomicIncrement32((int32*)scalar); }