ThermalForce::ThermalForce(Cloud * const C, const double redFactor) : Force(C), evenRandCache(new RandCache[C->n/DOUBLE_STRIDE]), oddRandCache(new RandCache[C->n/DOUBLE_STRIDE]), #ifdef DISPATCH_QUEUES evenRandGroup(dispatch_group_create()), oddRandGroup(dispatch_group_create()), randQueue(dispatch_queue_create("com.DEMON.ThermalForce", NULL)), #endif heatVal(redFactor) { #ifdef DISPATCH_QUEUES dispatch_group_async(oddRandGroup, randQueue, ^{ #endif for (cloud_index i = 0, e = cloud->n/DOUBLE_STRIDE; i < e; i++) oddRandCache[i] = RandCache(cloud->rands); #ifdef DISPATCH_QUEUES });
static void tests(void) { // CFStringRef messageToUser = CFSTR("OK to sync with world?"); // CFStringRef messageToUser = CFSTR("Allow “Emily‘s iPad to use your iCloud Keychain?"); #if !TARGET_IPHONE_SIMULATOR #if TARGET_OS_EMBEDDED CFStringRef our_peer_id = (CFStringRef)MGCopyAnswer(kMGQUserAssignedDeviceName, NULL); #else CFStringRef our_peer_id = CFSTR("🔥💩"); #endif #else CFStringRef our_peer_id = CFSTR("Emily‘s iPad"); #endif CFStringRef messageToUser = CFStringCreateWithFormat(kCFAllocatorDefault, 0, CFSTR("Allow “%@” to use your iCloud Keychain?"), our_peer_id); dispatch_queue_t processQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_group_t work_group = dispatch_group_create(); // Prep the group for exitting the whole shebang. dispatch_group_enter(work_group); dispatch_group_notify(work_group, processQueue, ^ { printf("Exiting via dispatch_group_notify; all work done\n"); CFRunLoopStop(CFRunLoopGetMain()); // exit(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 {
void test_dispatch_latency(unsigned samples, unsigned sleeptime) { unsigned i; uint64_t *lat = (uint64_t *)malloc(sizeof(uint64_t) * 3); uint64_t *history = (uint64_t *)malloc(sizeof(uint64_t) * samples); dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_group_t group = dispatch_group_create(); for (i = 0; i < samples; i++) { usleep(sleeptime); /* lat[0] to lat[1] is latency to block execution lat[1] to lat[2] is latency from block execution to block synchronization */ lat[0] = libtime_cpu(); dispatch_group_async(group, queue, ^{ lat[1] = libtime_cpu(); }); dispatch_group_wait(group, DISPATCH_TIME_FOREVER); lat[2] = libtime_cpu(); /* printf("%04u lat[0] = %" PRIu64 "\n", i, lat[0]); printf("%04u lat[1] = %" PRIu64 ", %" PRIu64 "\n", i, lat[1], lat[1] - lat[0]); printf("%04u lat[2] = %" PRIu64 ", %" PRIu64 "\n", i, lat[2], lat[2] - lat[1]); */ history[i] = lat[1] - lat[0]; //history[i] = lat[2] - lat[1]; }
static void render(unsigned char *img, int comps, int w, int h, int nsubsamples, int tilew, int tileh) { float *fimg = (float *)malloc(sizeof(float) * w * h * 3); memset((void *)fimg, 0, sizeof(float) * w * h * 3); dispatch_queue_t dque = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); //dispatch_queue_t dque = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_HIGH, 0); dispatch_group_t dgroup = dispatch_group_create(); int i, j; for (j = 0; j < h; j += tileh) { for (i = 0; i < w; i += tilew) { void (^renderblock)(void) = ^{ render_tile(img, comps, fimg, w, h, nsubsamples, i, j, tilew, tileh); }; //renderblock(); dispatch_group_async(dgroup, dque, renderblock); } } dispatch_group_wait(dgroup, DISPATCH_TIME_FOREVER); //dispatch_release(dgroup); }
static void do_test(void) { size_t i; char buf[1000]; dispatch_group_t g = dispatch_group_create(); for (i = 0; i < QUEUES; i++) { #ifdef WIN32 _snprintf(buf, sizeof(buf), "com.example.memoryload-node#%ld", i); #else snprintf(buf, sizeof(buf), "com.example.memoryload-node#%ld", (long int)i); #endif queues[i] = dispatch_queue_create(buf, NULL); dispatch_suspend(queues[i]); } for (i = 0; i < QUEUES; i++) { dispatch_group_async_f(g, queues[i], g, start_node); } dispatch_group_notify_f(g, dispatch_get_main_queue(), NULL, collect); for (i = 0; i < QUEUES; i++) { dispatch_resume(queues[i]); dispatch_release(queues[i]); } }
static void test_io_close(int with_timer, bool from_path) { #define chunks 4 #define READSIZE (512*1024) unsigned int i; const char *path = LARGE_FILE; int fd = open(path, O_RDONLY); if (fd == -1) { if (errno == ENOENT) { test_skip("Large file not found"); return; } test_errno("open", errno, 0); test_stop(); } #ifdef F_GLOBAL_NOCACHE if (fcntl(fd, F_GLOBAL_NOCACHE, 1) == -1) { test_errno("fcntl F_GLOBAL_NOCACHE", errno, 0); test_stop(); } #endif struct stat sb; if (fstat(fd, &sb)) { test_errno("fstat", errno, 0); test_stop(); } const size_t size = (size_t)sb.st_size / chunks; const int expected_error = with_timer? ECANCELED : 0; dispatch_source_t t = NULL; dispatch_group_t g = dispatch_group_create(); dispatch_group_enter(g); void (^cleanup_handler)(int error) = ^(int error) { test_errno("create error", error, 0); dispatch_group_leave(g); close(fd); }; dispatch_io_t io; if (!from_path) { io = dispatch_io_create(DISPATCH_IO_RANDOM, fd, dispatch_get_global_queue(0, 0), cleanup_handler); } else { #if DISPATCHTEST_IO_PATH io = dispatch_io_create_with_path(DISPATCH_IO_RANDOM, path, O_RDONLY, 0, dispatch_get_global_queue(0, 0), cleanup_handler); #endif } dispatch_io_set_high_water(io, READSIZE); if (with_timer == 1) { dispatch_io_set_low_water(io, READSIZE); dispatch_io_set_interval(io, 2 * NSEC_PER_SEC, DISPATCH_IO_STRICT_INTERVAL); } else if (with_timer == 2) { t = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, dispatch_get_global_queue(0,0)); dispatch_retain(io); dispatch_source_set_event_handler(t, ^{ dispatch_io_close(io, DISPATCH_IO_STOP); dispatch_source_cancel(t); });
static VALUE rb_group_init(VALUE self, SEL sel) { RGroup(self)->group = dispatch_group_create(); assert(RGroup(self)->group != NULL); return self; }
__XDISPATCH_USE_NAMESPACE group::group () : object(), m_native( dispatch_group_create() ) { XDISPATCH_ASSERT( m_native ); }
RequestTimer::RequestTimer(RequestInjectionData* data) : m_reqInjectionData(data) { // Unlike the canonical Linux implementation, this does not distinguish // between whether we wanted real seconds or CPU seconds -- you always get // real seconds. There isn't a nice way to get CPU seconds on OS X that I've // found, outside of setitimer, which has its own configurability issues. So // we just always give real seconds, which is "close enough". m_timerGroup = dispatch_group_create(); }
void test_proc(pid_t bad_pid) { dispatch_source_t proc_s[PID_CNT], proc; int res; pid_t pid, monitor_pid; event_cnt = 0; // Creates a process and register multiple observers. Send a signal, // exit the process, etc., and verify all observers were notified. posix_spawnattr_t attr; res = posix_spawnattr_init(&attr); assert(res == 0); #if HAVE_DECL_POSIX_SPAWN_START_SUSPENDED res = posix_spawnattr_setflags(&attr, POSIX_SPAWN_START_SUSPENDED); assert(res == 0); #endif char* args[] = { "/bin/sleep", "2", NULL }; res = posix_spawnp(&pid, args[0], NULL, &attr, args, NULL); if (res < 0) { perror(args[0]); exit(127); } res = posix_spawnattr_destroy(&attr); assert(res == 0); dispatch_group_t group = dispatch_group_create(); assert(pid > 0); monitor_pid = bad_pid ? bad_pid : pid; // rdar://problem/8090801 int i; for (i = 0; i < PID_CNT; ++i) { dispatch_group_enter(group); proc = proc_s[i] = dispatch_source_create(DISPATCH_SOURCE_TYPE_PROC, monitor_pid, DISPATCH_PROC_EXIT, dispatch_get_global_queue(0, 0)); test_ptr_notnull("dispatch_source_proc_create", proc); dispatch_source_set_event_handler(proc, ^{ long flags = dispatch_source_get_data(proc); test_long("DISPATCH_PROC_EXIT", flags, DISPATCH_PROC_EXIT); event_cnt++; dispatch_source_cancel(proc); }); dispatch_source_set_cancel_handler(proc, ^{ dispatch_group_leave(group); });
static void tests(void) { SKIP: { skip("Skipping ckdclient tests because CloudKeychainProxy.xpc is not installed", kTestTestCount, XPCServiceInstalled()); // dispatch_queue_t dqueue = dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); xpc_queue = dispatch_queue_create("sc_90_ckdclient", DISPATCH_QUEUE_SERIAL); sDispatchGroup = dispatch_group_create(); initializeTestData(); basicKVSTests(sDispatchGroup); } }
int main(int argc, const char *argv[]) { dispatch_queue_t queue = dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0); dispatch_group_t group = dispatch_group_create(); __block int sum = 0; for (int i = 0; i < 10; i++) { dispatch_group_async(group, queue, ^{ printf("+%d\n", i); sum += i; }); }
void ISPCLaunch(void *func, void *data) { if (!initialized) { while (1) { if (lAtomicCompareAndSwap32(&lock, 1, 0) == 0) { if (!initialized) { gcdQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); gcdGroup = dispatch_group_create(); lInitTaskInfo(); __asm__ __volatile__("mfence":::"memory"); initialized = 1; } lock = 0; break; } } }
void dispatch_apply_fwrite(uint32_t* data) { dispatch_queue_t queue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); dispatch_group_t group = dispatch_group_create(); for (int fi = 0; fi < kNumFiles; ++fi) dispatch_group_enter(group); // There's no dispatch_group_apply(). dispatch_apply(kNumFiles, queue, ^(size_t fi) { char buf[80]; sprintf(buf, "f%02d.out", (int)fi); FILE* f = fopen(buf, "wb"); fwrite(data + fi * kIntChunkSize, 1, kChunkSize, f); fclose(f); dispatch_group_leave(group); });
/* Lua-side of rendering context */ static void create_lua_context (struct vox_engine *engine) { lua_State *L = engine->L; if (engine->flags & VOX_ENGINE_DEBUG) { /* In debug mode we just create an empty table for context. */ lua_newtable (L); } else { struct context_data *data = lua_newuserdata (L, sizeof (struct context_data)); luaL_getmetatable (L, CONTEXT_META); lua_setmetatable (L, -2); data->context = engine->ctx; data->rendering_group = dispatch_group_create (); data->rendering_queue = dispatch_queue_create ("scene operations", 0); } }
void test_short_timer(void) { // Add a large number of timers with suspended target queue in front of // the timer being measured <rdar://problem/7401353> g = dispatch_group_create(); q = dispatch_queue_create("q", NULL); int i; for (i = 0; i < N; i++) { t[i] = dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, q); dispatch_source_set_timer(t[i], DISPATCH_TIME_NOW, interval, 0); dispatch_group_enter(g); dispatch_source_set_registration_handler(t[i], ^{ dispatch_suspend(t[i]); dispatch_group_leave(g); }); dispatch_resume(t[i]); }
static dispatch_group_t create_group(size_t count, int delay) { size_t i; int* param; dispatch_group_t group = dispatch_group_create(); for (i = 0; i < count; ++i) { dispatch_queue_t queue = dispatch_queue_create("foo", NULL); param = (int*)malloc(sizeof(int)); *param = delay; MU_ASSERT_NOT_NULL(queue); MU_ASSERT_NOT_NULL(param); dispatch_group_async_f(group, queue, param, work); dispatch_release(queue); } return group; }
dispatch_group_t create_group(size_t count, int delay) { size_t i; dispatch_group_t group = dispatch_group_create(); for (i = 0; i < count; ++i) { dispatch_queue_t queue = dispatch_queue_create(NULL, NULL); assert(queue); dispatch_group_async(group, queue, ^{ if (delay) { fprintf(stderr, "sleeping...\n"); sleep(delay); fprintf(stderr, "done.\n"); } }); dispatch_release(queue); }
int main(void) { test_start("Dispatch Debug"); dispatch_queue_t main_q = dispatch_get_main_queue(); dispatch_debug(main_q, "dispatch_queue_t"); dispatch_queue_t default_q = dispatch_get_concurrent_queue(0); dispatch_debug(default_q, "dispatch_queue_t"); dispatch_source_attr_t attr = dispatch_source_attr_create(); dispatch_debug(attr, "dispatch_source_attr_t"); dispatch_source_t s = dispatch_source_timer_create(DISPATCH_TIMER_INTERVAL, 1000000000ull, 0, attr, main_q, ^(dispatch_event_t ev __attribute__((unused))) {}); dispatch_debug(s, "dispatch_source_t"); dispatch_group_t g = dispatch_group_create(); dispatch_debug(g, "dispatch_group_t"); return 0; }
int main(int argc, char *argv[]) { int i; dispatch_group_t g = dispatch_group_create(); dispatch_queue_t q = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); struct timespec ts3 = {3, 0}; struct timespec ts1 = {1, 0}; struct timeval basetime, etime; printf("loop start\n"); gettimeofday(&basetime, NULL); for (i = 0; i < 10; i++) { dispatch_group_async(g, q, ^{ pthread_t p = pthread_self(); struct timeval tp; nanosleep(&ts3, NULL); gettimeofday(&tp, NULL); { int j = i; pthread_t q = pthread_self(); struct timeval tq; gettimeofday(&tq, NULL); printf( "hello count %d\n" "running thread %p time: %ld\n" "printing thread %p time: %ld\n" "\n", j, p, tp.tv_sec - basetime.tv_sec, q, tq.tv_sec - basetime.tv_sec); } }); nanosleep(&ts1, NULL); }
#include <Security/Security.h> #include <stdlib.h> #define BLOCKS 7000 static void tests() { SecKeychainRef kc = getPopulatedTestKeychain(); static dispatch_once_t onceToken = 0; static dispatch_queue_t release_queue = NULL; dispatch_once(&onceToken, ^{ release_queue = dispatch_queue_create("com.apple.security.identity-search-queue", DISPATCH_QUEUE_CONCURRENT); }); dispatch_group_t g = dispatch_group_create(); for(int i = 0; i < BLOCKS; i++) { dispatch_group_async(g, release_queue, ^() { SecKeychainItemRef blockItem = NULL; CFMutableDictionaryRef query = createQueryCustomItemDictionaryWithService(kc, kSecClassInternetPassword, CFSTR("test_service"), CFSTR("test_service")); CFDictionarySetValue(query, kSecMatchLimit, kSecMatchLimitOne); ok_status(SecItemCopyMatching(query, (CFTypeRef*) &blockItem), "%s: SecItemCopyMatching(%d)", testName, i); CFReleaseNull(blockItem); }); } dispatch_group_wait(g, DISPATCH_TIME_FOREVER);
dispatch_group_t createGroup() { return dispatch_group_create(); }
#include <sys/stat.h> #include <sys/param.h> #include <sys/sysctl.h> #endif // WIN32 #include <list> // Parallel Local Declarations #if defined(PBRT_HAS_PTHREADS) && !defined(PBRT_USE_GRAND_CENTRAL_DISPATCH) static pthread_t *threads; #endif #ifdef WIN32 static HANDLE *threads; #endif // WIN32 #ifdef PBRT_USE_GRAND_CENTRAL_DISPATCH static dispatch_queue_t gcdQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); static dispatch_group_t gcdGroup = dispatch_group_create(); #else static Mutex *taskQueueMutex = Mutex::Create(); static std::vector<Task *> taskQueue; #endif // PBRT_USE_GRAND_CENTRAL_DISPATCH #ifndef PBRT_USE_GRAND_CENTRAL_DISPATCH static Semaphore workerSemaphore; static uint32_t numUnfinishedTasks; static ConditionVariable tasksRunningCondition; #endif // PBRT_USE_GRAND_CENTRAL_DISPATCH #ifndef PBRT_USE_GRAND_CENTRAL_DISPATCH static #ifdef WIN32 DWORD WINAPI taskEntry(LPVOID arg); #else void *taskEntry(void *arg);
} /* Wait at least three seconds for our sources to flush to ASL */ dispatch_group_wait(read_source_group, dispatch_time(DISPATCH_TIME_NOW, 3LL * NSEC_PER_SEC)); } static void asl_descriptor_init(void *ctx __unused) { assert((redirect_descriptors = calloc(16, sizeof(*redirect_descriptors))) != NULL); n_redirect_descriptors = 16; redirect_serial_q = dispatch_queue_create("com.apple.asl-redirect", NULL); assert(redirect_serial_q != NULL); read_source_group = dispatch_group_create(); assert(read_source_group != NULL); atexit(redirect_atexit); } static int asl_log_from_descriptor(aslclient ac, aslmsg am, int level, int descriptor) { int err __block = 0; static dispatch_once_t once_control; dispatch_once_f(&once_control, NULL, asl_descriptor_init); asl_client_t *asl = (asl_client_t *)ac; asl_msg_t *msg = (asl_msg_t *)am; if (descriptor < 0) return EBADF;
void TasksInit() { gcdQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); gcdGroup = dispatch_group_create(); initialized = true; }
int main(int argc, char** argv) { struct hostent *he; int sockfd, clientfd; struct sockaddr_in addr1, addr2, server; socklen_t addr2len; socklen_t addr1len; pid_t clientid; const char *path = "/usr/share/dict/words"; int read_fd, fd; if (argc == 2) { // Client dispatch_test_start(NULL); if ((sockfd = socket(AF_INET, SOCK_STREAM, 0)) == -1) { test_errno("Client-socket()", errno, 0); test_stop(); } if ((he = gethostbyname("localhost")) == NULL) { fprintf(stderr, "Client-gethostbyname() failed\n"); test_stop(); } memcpy(&server.sin_addr, he->h_addr_list[0], he->h_length); server.sin_family = AF_INET; server.sin_port = atoi(argv[1]); fprintf(stderr, "Client-connecting on port ... %d\n", server.sin_port); if (connect(sockfd, (struct sockaddr *)&server, sizeof(server))) { test_errno("client-connect()", errno, 0); test_stop(); } // Read from the socket and compare the contents are what we expect fd = open(path, O_RDONLY); if (fd == -1) { test_errno("client-open", errno, 0); test_stop(); } #ifdef F_NOCACHE if (fcntl(fd, F_NOCACHE, 1)) { test_errno("client-fcntl F_NOCACHE", errno, 0); test_stop(); } #else // investigate what the impact of lack of file cache disabling has // for this test #endif struct stat sb; if (fstat(fd, &sb)) { test_errno("client-fstat", errno, 0); test_stop(); } size_t size = sb.st_size; __block dispatch_data_t g_d1 = dispatch_data_empty; __block dispatch_data_t g_d2 = dispatch_data_empty; __block int g_error = 0; dispatch_group_t g = dispatch_group_create(); dispatch_group_enter(g); dispatch_read(fd, size, dispatch_get_global_queue(0, 0), ^(dispatch_data_t d1, int error) { test_errno("Client-dict-read error", error, 0); test_long("Client-dict-dispatch data size", dispatch_data_get_size(d1), size); dispatch_retain(d1); g_d1 = d1; dispatch_group_leave(g); });
void DetectionManager::processDetection(ImageData *image) { int threads = 4; dispatch_queue_t queue[4]; for (int i = 0 ; i < threads; i++) { queue[i] = dispatch_queue_create("Threads", DISPATCH_QUEUE_CONCURRENT); } double simulation_time = read_timer(); //preprocess shopTopLeftCorner = NULL; shopTopLeftCornerShown = false; allyMinions->clear(); enemyMinions->clear(); allyChampions->clear(); enemyChampions->clear(); selfChampions->clear(); enemyTowers->clear(); buyableItems->clear(); spell1LevelDots->clear(); spell2LevelDots->clear(); spell3LevelDots->clear(); spell4LevelDots->clear(); dispatch_group_t dispatchGroup = dispatch_group_create(); ////#pragma omp parallel num_threads(128) for (int threadNum = 0; threadNum < threads; threadNum++) { dispatch_group_async(dispatchGroup, queue[threadNum], ^{ int perThread = (image->imageWidth * image->imageHeight) / threads;// / omp_get_num_threads(); int start = threadNum * perThread; int end = (threadNum + 1) * perThread; int x = start % (image->imageWidth); int y = start / (image->imageWidth); uint8_t* pixel = getPixel2(image, x, y); Minion* minionBar; Champion* championBar; Tower* towerBar; GenericObject* topLeftCorner; for (int xy = start; xy < end; ++xy) { if (x >= image->imageWidth) { x = 0; y++; } //Ally minion detection minionBar = AllyMinionManager::detectMinionBarAtPixel(image, pixel, x, y); if (minionBar != NULL) { //#pragma omp critical (addAllyMinion) allyMinions->push_back(minionBar); } //Enemy minion detection minionBar = EnemyMinionManager::detectMinionBarAtPixel(image, pixel, x, y); if (minionBar != NULL) { //#pragma omp critical (addEnemyMinion) enemyMinions->push_back(minionBar); } //Enemy champion detection championBar = EnemyChampionManager::detectChampionBarAtPixel(image, pixel, x, y); if (championBar != NULL) { //#pragma omp critical (addEnemyChampion) enemyChampions->push_back(championBar); } //Ally champion detection championBar = AllyChampionManager::detectChampionBarAtPixel(image, pixel, x, y); if (championBar != NULL) { //#pragma omp critical (addAllyChampion) allyChampions->push_back(championBar); } //Enemy tower detection towerBar = EnemyTowerManager::detectTowerBarAtPixel(image, pixel, x, y); if (towerBar != NULL) { //#pragma omp critical (addEnemyTower) enemyTowers->push_back(towerBar); } //Self champion detection championBar = SelfChampionManager::detectChampionBarAtPixel(image, pixel, x, y); if (championBar != NULL) { //#pragma omp critical (addSelfChampion) selfChampions->push_back(championBar); } //Shop window detection if (shopTopLeftCorner == NULL) { topLeftCorner = ShopManager::detectShopTopLeftCorner(image, pixel, x, y); if (topLeftCorner != NULL) { shopTopLeftCorner = topLeftCorner; shopTopLeftCornerShown = true; } } x++; pixel += 4; } }); }
Boolean SCDynamicStoreSetDispatchQueue(SCDynamicStoreRef store, dispatch_queue_t queue) { dispatch_group_t drainGroup = NULL; dispatch_queue_t drainQueue = NULL; dispatch_group_t group = NULL; mach_port_t mp; Boolean ok = FALSE; dispatch_source_t source; SCDynamicStorePrivateRef storePrivate = (SCDynamicStorePrivateRef)store; if (store == NULL) { // sorry, you must provide a session _SCErrorSet(kSCStatusNoStoreSession); return FALSE; } if (queue == NULL) { if (storePrivate->dispatchQueue == NULL) { _SCErrorSet(kSCStatusInvalidArgument); return FALSE; } ok = TRUE; goto cleanup; } if (storePrivate->server == MACH_PORT_NULL) { // sorry, you must have an open session to play _SCErrorSet(kSCStatusNoStoreServer); return FALSE; } if ((storePrivate->dispatchQueue != NULL) || (storePrivate->rls != NULL)) { _SCErrorSet(kSCStatusInvalidArgument); return FALSE; } if (storePrivate->notifyStatus != NotifierNotRegistered) { // sorry, you can only have one notification registered at once... _SCErrorSet(kSCStatusNotifierActive); return FALSE; } /* * mark our using of the SCDynamicStore notifications, create and schedule * the notification port (storePrivate->rlsNotifyPort), and a bunch of other * "setup" */ storePrivate->notifyStatus = Using_NotifierInformViaDispatch; rlsSchedule((void*)store, NULL, NULL); if (storePrivate->rlsNotifyPort == NULL) { /* if we could not schedule the notification */ _SCErrorSet(kSCStatusFailed); goto cleanup; } // retain the dispatch queue storePrivate->dispatchQueue = queue; dispatch_retain(storePrivate->dispatchQueue); // // We've taken a reference to the callers dispatch_queue and we // want to hold on to that reference until we've processed any/all // notifications. To facilitate this we create a group, dispatch // any notification blocks to via that group, and when the caller // has told us to stop the notifications (unschedule) we wait for // the group to empty and use the group's finalizer to release // our reference to the SCDynamicStore. // group = dispatch_group_create(); storePrivate->dispatchGroup = group; CFRetain(store); dispatch_set_context(storePrivate->dispatchGroup, (void *)store); dispatch_set_finalizer_f(storePrivate->dispatchGroup, (dispatch_function_t)CFRelease); // create a dispatch source for the mach notifications mp = CFMachPortGetPort(storePrivate->rlsNotifyPort); source = dispatch_source_create(DISPATCH_SOURCE_TYPE_MACH_RECV, mp, 0, queue); if (source == NULL) { SCLog(TRUE, LOG_ERR, CFSTR("SCDynamicStore dispatch_source_create() failed")); _SCErrorSet(kSCStatusFailed); goto cleanup; } dispatch_source_set_event_handler(source, ^{ kern_return_t kr; mach_msg_id_t msgid; union { u_int8_t buf[sizeof(mach_msg_empty_t) + MAX_TRAILER_SIZE]; mach_msg_empty_rcv_t msg; mach_no_senders_notification_t no_senders; } notify_msg; kr = mach_msg(¬ify_msg.msg.header, // msg MACH_RCV_MSG, // options 0, // send_size sizeof(notify_msg), // rcv_size mp, // rcv_name MACH_MSG_TIMEOUT_NONE, // timeout MACH_PORT_NULL); // notify if (kr != KERN_SUCCESS) { SCLog(TRUE, LOG_ERR, CFSTR("SCDynamicStore notification handler, kr=0x%x"), kr); return; } msgid = notify_msg.msg.header.msgh_id; CFRetain(store); dispatch_group_async(group, queue, ^{ if (msgid == MACH_NOTIFY_NO_SENDERS) { // re-establish notification and inform the client (void)__SCDynamicStoreReconnectNotifications(store); } rlsPerform(storePrivate); CFRelease(store); }); });