/** * @brief Destroy a stream. * @protected * * @warning This function must only be used to implement a subclass of * @ref SquashObject. Each subclass should implement a *_destroy * function which should perform any operations needed to destroy * their own data and chain up to the *_destroy function of the base * class, eventually invoking ::squash_object_destroy. Invoking this * function in any other context is likely to cause a memory leak or * crash. If you are not creating a subclass, you should be calling * @ref squash_object_unref instead. * * @param stream The stream. * * @see squash_object_destroy */ void squash_stream_destroy (void* stream) { SquashStream* s; assert (stream != NULL); s = (SquashStream*) stream; if (SQUASH_UNLIKELY(s->priv != NULL)) { SquashStreamPrivate* priv = (SquashStreamPrivate*) s->priv; if (!priv->finished) { squash_stream_send_to_thread (s, SQUASH_OPERATION_TERMINATE); } cnd_destroy (&(priv->request_cnd)); cnd_destroy (&(priv->result_cnd)); mtx_destroy (&(priv->io_mtx)); squash_free (s->priv); } if (s->destroy_user_data != NULL && s->user_data != NULL) { s->destroy_user_data (s->user_data); } if (s->options != NULL) { s->options = squash_object_unref (s->options); } squash_object_destroy (stream); }
bool RWMutex::destroy() { if(initialized) { if(mtx_lock(&mtxExclusiveAccess) != thrd_success) return false; if(mtx_lock(&mtxSharedAccessCompleted) != thrd_success) { mtx_unlock(&mtxExclusiveAccess); return false; } if(nExclusiveAccessCount > 0 || nSharedAccessCount > nCompletedSharedAccessCount) { // Busy int j = 27; } mtx_unlock(&mtxSharedAccessCompleted); mtx_unlock(&mtxExclusiveAccess); cnd_destroy(&cndSharedAccessCompleted); mtx_destroy(&mtxSharedAccessCompleted); mtx_destroy(&mtxExclusiveAccess); initialized = false; } return true; }
/* ==================== TFile_StartServer ==================== */ void TFile_StartServer( void ) { server_message_t message; if ( !server_initialized ) { T_FatalError( "TFile_StartServer: Server is not initialized" ); } if ( server_running ) { T_FatalError( "TFile_StartServer: Server is already running" ); } cnd_init( &server_condition ); mtx_init( &server_mutex, mtx_plain ); mtx_lock( &server_mutex ); message.ip_socket = server_socket; message.ip6_socket = server_socket6; if ( thrd_create( &server_thread, ServerThread, &message ) != thrd_success ) { T_FatalError( "TFile_StartServer: Unable to create thread" ); } cnd_wait( &server_condition, &server_mutex ); mtx_destroy( &server_mutex ); cnd_destroy( &server_condition ); server_running = t_true; }
int main(void) { SetConsoleTitle(TITLE); mtx_init(&gmutex, mtx_plain); cnd_init(&gcond); init_timer(); init_path(); init_strings(); init_server(); initpackets(); //test_map(1); thrd_create(&t1, initsocket, (void*)0); thrd_create(&t2, commands, (void*)0); server_loop(); destroy_server(); mtx_destroy(&gmutex); cnd_destroy(&gcond); #if _DEBUG VLDReportLeaks(); #endif exit(TRUE);// Exit program }
void util_ringbuffer_destroy( struct util_ringbuffer *ring ) { cnd_destroy(&ring->change); mtx_destroy(&ring->mutex); FREE(ring->buf); FREE(ring); }
void Condition_Deinit(COND_HANDLE handle) { // Codes_SRS_CONDITION_18_007: [ Condition_Deinit will not fail if handle is NULL ] if (handle != NULL) { // Codes_SRS_CONDITION_18_009: [ Condition_Deinit will deallocate handle if it is not NULL cnd_t* cond = (cnd_t*)handle; cnd_destroy(cond); free(cond); } }
void rd_kafka_timers_destroy (rd_kafka_timers_t *rkts) { rd_kafka_timer_t *rtmr; rd_kafka_assert(NULL, TAILQ_EMPTY(&rkts->rkts_timers)); while ((rtmr = TAILQ_FIRST(&rkts->rkts_timers))) rd_kafka_timer_stop(rkts, rtmr, 0); rd_kafka_assert(rkts->rkts_rk, TAILQ_EMPTY(&rkts->rkts_timers)); cnd_destroy(&rkts->rkts_cond); mtx_destroy(&rkts->rkts_lock); }
void db_worker_stop() { if (!db_enabled) { return; } mtx_lock(&mtx); ring_put_exit(&ring); cnd_signal(&cnd); mtx_unlock(&mtx); thrd_join(thrd, NULL); cnd_destroy(&cnd); mtx_destroy(&mtx); ring_free(&ring); }
static void do_test_apis (rd_kafka_type_t cltype) { rd_kafka_t *rk; char errstr[512]; rd_kafka_queue_t *mainq, *backgroundq; rd_kafka_conf_t *conf; mtx_init(&last_event_lock, mtx_plain); cnd_init(&last_event_cnd); do_test_unclean_destroy(cltype, 0/*tempq*/); do_test_unclean_destroy(cltype, 1/*mainq*/); test_conf_init(&conf, NULL, 0); /* Remove brokers, if any, since this is a local test and we * rely on the controller not being found. */ test_conf_set(conf, "bootstrap.servers", ""); test_conf_set(conf, "socket.timeout.ms", MY_SOCKET_TIMEOUT_MS_STR); /* For use with the background queue */ rd_kafka_conf_set_background_event_cb(conf, background_event_cb); rk = rd_kafka_new(cltype, conf, errstr, sizeof(errstr)); TEST_ASSERT(rk, "kafka_new(%d): %s", cltype, errstr); mainq = rd_kafka_queue_get_main(rk); backgroundq = rd_kafka_queue_get_background(rk); do_test_options(rk); do_test_CreateTopics("temp queue, no options", rk, NULL, 0, 0); do_test_CreateTopics("temp queue, no options, background_event_cb", rk, backgroundq, 1, 0); do_test_CreateTopics("temp queue, options", rk, NULL, 0, 1); do_test_CreateTopics("main queue, options", rk, mainq, 0, 1); do_test_DeleteTopics("temp queue, no options", rk, NULL, 0); do_test_DeleteTopics("temp queue, options", rk, NULL, 1); do_test_DeleteTopics("main queue, options", rk, mainq, 1); do_test_mix(rk, mainq); do_test_configs(rk, mainq); rd_kafka_queue_destroy(backgroundq); rd_kafka_queue_destroy(mainq); rd_kafka_destroy(rk); mtx_destroy(&last_event_lock); cnd_destroy(&last_event_cnd); }
/** * Destroy a queue. refcnt must be at zero. */ void rd_kafka_q_destroy_final (rd_kafka_q_t *rkq) { mtx_lock(&rkq->rkq_lock); rd_kafka_q_fwd_set0(rkq, NULL, 0/*no-lock*/); rd_kafka_q_disable0(rkq, 0/*no-lock*/); rd_kafka_q_purge0(rkq, 0/*no-lock*/); assert(!rkq->rkq_fwdq); mtx_unlock(&rkq->rkq_lock); mtx_destroy(&rkq->rkq_lock); cnd_destroy(&rkq->rkq_cond); if (rkq->rkq_flags & RD_KAFKA_Q_F_ALLOCATED) rd_free(rkq); }
int main(int argc, char** argv) { int res; mtx_init(&gMutex, mtx_plain); cnd_init(&gCond); res = tests_run(unit_tests, argc, argv); mtx_destroy(&gMutex); cnd_destroy(&gCond); return res; }
/* This is the main program (i.e. the main thread) */ int main(void) { /* Initialization... */ mtx_init(&gMutex, mtx_plain); cnd_init(&gCond); /* Test 1: thread arguments & return values */ printf("PART I: Thread arguments & return values\n"); { thrd_t t1, t2, t3, t4; int id1, id2, id3, id4, ret1, ret2, ret3, ret4; /* Start a bunch of child threads */ id1 = 1; thrd_create(&t1, ThreadIDs, (void*)&id1); thrd_join(t1, &ret1); printf(" Thread 1 returned %d.\n", ret1); id2 = 2; thrd_create(&t2, ThreadIDs, (void*)&id2); thrd_join(t2, &ret2); printf(" Thread 2 returned %d.\n", ret2); id3 = 3; thrd_create(&t3, ThreadIDs, (void*)&id3); thrd_join(t3, &ret3); printf(" Thread 3 returned %d.\n", ret3); id4 = 4; thrd_create(&t4, ThreadIDs, (void*)&id4); thrd_join(t4, &ret4); printf(" Thread 4 returned %d.\n", ret4); } /* Test 2: compile time thread local storage */ printf("PART II: Compile time thread local storage\n"); #ifndef NO_CT_TLS { thrd_t t1; /* Clear the TLS variable (it should keep this value after all threads are finished). */ gLocalVar = 1; printf(" Main gLocalVar is %d.\n", gLocalVar); /* Start a child thread that modifies gLocalVar */ thrd_create(&t1, ThreadTLS, NULL); thrd_join(t1, NULL); /* Check if the TLS variable has changed */ if(gLocalVar == 1) printf(" Main gLocalID was not changed by the child thread - OK!\n"); else printf(" Main gLocalID was changed by the child thread - FAIL!\n"); } #else printf(" Compile time TLS is not supported on this platform...\n"); #endif /* Test 3: mutex locking */ printf("PART III: Mutex locking (100 threads x 10000 iterations)\n"); { thrd_t t[100]; int i; /* Clear the global counter. */ gCount = 0; /* Start a bunch of child threads */ for (i = 0; i < 100; ++ i) { thrd_create(&t[i], ThreadLock, NULL); } /* Wait for the threads to finish */ for (i = 0; i < 100; ++ i) { thrd_join(t[i], NULL); } /* Check the global count */ printf(" gCount = %d\n", gCount); } /* Test 4: condition variable */ printf("PART IV: Condition variable (40 + 1 threads)\n"); { thrd_t t1, t[40]; int i; /* Set the global counter to the number of threads to run. */ gCount = 40; /* Start the waiting thread (it will wait for gCount to reach zero). */ thrd_create(&t1, ThreadCondition2, NULL); /* Start a bunch of child threads (these will decrease gCount by 1 when they finish) */ for (i = 0; i < 40; ++ i) { thrd_create(&t[i], ThreadCondition1, NULL); } /* Wait for the waiting thread to finish */ thrd_join(t1, NULL); /* Wait for the other threads to finish */ for (i = 0; i < 40; ++ i) { thrd_join(t[i], NULL); } } /* Test 5: yield */ printf("PART V: Yield (40 + 1 threads)\n"); { thrd_t t[40]; int i; /* Start a bunch of child threads */ for (i = 0; i < 40; ++ i) { thrd_create(&t[i], ThreadYield, NULL); } /* Yield... */ thrd_yield(); /* Wait for the threads to finish */ for (i = 0; i < 40; ++ i) { thrd_join(t[i], NULL); } } /* Test 6: Sleep */ printf("PART VI: Sleep (10 x 100 ms)\n"); { int i; struct timespec ts; printf(" Sleeping"); fflush(stdout); for (i = 0; i < 10; ++ i) { /* Calculate current time + 100ms */ clock_gettime(TIME_UTC, &ts); ts.tv_nsec += 100000000; if (ts.tv_nsec >= 1000000000) { ts.tv_sec++; ts.tv_nsec -= 1000000000; } /* Sleep... */ thrd_sleep(&ts, NULL); printf("."); fflush(stdout); } printf("\n"); } /* Test 7: Time */ printf("PART VII: Current time (UTC), three times\n"); { struct timespec ts; clock_gettime(TIME_UTC, &ts); printf(" Time = %ld.%09ld\n", (long)ts.tv_sec, ts.tv_nsec); clock_gettime(TIME_UTC, &ts); printf(" Time = %ld.%09ld\n", (long)ts.tv_sec, ts.tv_nsec); clock_gettime(TIME_UTC, &ts); printf(" Time = %ld.%09ld\n", (long)ts.tv_sec, ts.tv_nsec); } /* FIXME: Implement some more tests for the TinyCThread API... */ /* Finalization... */ mtx_destroy(&gMutex); cnd_destroy(&gCond); return 0; }
/** * @brief Test that Metadata requests are retried properly when * timing out due to high broker rtt. */ static void do_test_low_socket_timeout (const char *topic) { rd_kafka_t *rk; rd_kafka_conf_t *conf; rd_kafka_topic_t *rkt; rd_kafka_resp_err_t err; const struct rd_kafka_metadata *md; int res; mtx_init(&ctrl.lock, mtx_plain); cnd_init(&ctrl.cnd); TEST_SAY("Test Metadata request retries on timeout\n"); test_conf_init(&conf, NULL, 60); test_conf_set(conf, "socket.timeout.ms", "1000"); test_conf_set(conf, "socket.max.fails", "12345"); test_conf_set(conf, "retry.backoff.ms", "5000"); /* Avoid api version requests (with their own timeout) to get in * the way of our test */ test_conf_set(conf, "api.version.request", "false"); test_socket_enable(conf); test_curr->connect_cb = connect_cb; test_curr->is_fatal_cb = is_fatal_cb; rk = test_create_handle(RD_KAFKA_PRODUCER, conf); rkt = test_create_producer_topic(rk, topic, NULL); TEST_SAY("Waiting for sockem connect..\n"); mtx_lock(&ctrl.lock); while (!ctrl.skm) cnd_wait(&ctrl.cnd, &ctrl.lock); mtx_unlock(&ctrl.lock); TEST_SAY("Connected, fire off a undelayed metadata() to " "make sure connection is up\n"); err = rd_kafka_metadata(rk, 0, rkt, &md, tmout_multip(2000)); TEST_ASSERT(!err, "metadata(undelayed) failed: %s", rd_kafka_err2str(err)); rd_kafka_metadata_destroy(md); if (thrd_create(&ctrl.thrd, ctrl_thrd_main, NULL) != thrd_success) TEST_FAIL("Failed to create sockem ctrl thread"); set_delay(0, 3000); /* Takes effect immediately */ /* After two retries, remove the delay, the third retry * should kick in and work. */ set_delay(((1000 /*socket.timeout.ms*/ + 5000 /*retry.backoff.ms*/) * 2) - 2000, 0); TEST_SAY("Calling metadata() again which should succeed after " "3 internal retries\n"); /* Metadata should be returned after the third retry */ err = rd_kafka_metadata(rk, 0, rkt, &md, ((1000 /*socket.timeout.ms*/ + 5000 /*retry.backoff.ms*/) * 2) + 5000); TEST_SAY("metadata() returned %s\n", rd_kafka_err2str(err)); TEST_ASSERT(!err, "metadata(undelayed) failed: %s", rd_kafka_err2str(err)); rd_kafka_metadata_destroy(md); rd_kafka_topic_destroy(rkt); rd_kafka_destroy(rk); /* Join controller thread */ mtx_lock(&ctrl.lock); ctrl.term = 1; mtx_unlock(&ctrl.lock); thrd_join(ctrl.thrd, &res); cnd_destroy(&ctrl.cnd); mtx_destroy(&ctrl.lock); }
void stack10_Destructor(Stack10 *s){ mtx_destroy(&s->mtx_); cnd_destroy(&s->cnd_push_); cnd_destroy(&s->cnd_pop_); }
int main(int argc, char** argv) { signal(SIGINT, IntHandler); Server serv; // Initialize the server InitConfig(&serv.conf, argv[1], argc, argv); if(!serv.conf.name) { fprintf(stderr, "Script doesn't specify a server name.\n"); return 1; } if(!serv.conf.port) { fprintf(stderr, "Script doesn't specify a port.\n"); return 1; } printf("Successfully configured server.\n" "Name: %s\n" "Port: %s\n" "Num Threads: %d\n" "Cycles Per Loop: %d\n" "Num Routes: %d\n", serv.conf.name, serv.conf.port, serv.conf.numThreads, serv.conf.cyclesPerLoop, sb_count(serv.conf.routes)); InitList(&serv.clientQueue, sizeof(Sock)); InitList(&serv.requestQueue, sizeof(ClientRequest)); cnd_init(&serv.updateLoop); cnd_init(&serv.newConn); // The loop thread is responsible for initializing LoopData thrd_t loopThread, connThread; thrd_create(&loopThread, MainLoop, &serv); thrd_create(&connThread, ConnLoop, &serv); // Initialize winsock and listen for clients WSADATA wsaData; SOCKET listenSocket; int iResult = WSAStartup(MAKEWORD(2,2), &wsaData); if(iResult != 0) { fprintf(stderr, "WSAStartup failed: %d\n", iResult); return 1; } struct addrinfo hints; ZeroMemory(&hints, sizeof(hints)); hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; hints.ai_flags = AI_PASSIVE; struct addrinfo* result; iResult = getaddrinfo(NULL, serv.conf.port, &hints, &result); if(iResult != 0) { fprintf(stderr, "getaddrinfo failed: %d\n", iResult); WSACleanup(); return 1; } listenSocket = socket(result->ai_family, result->ai_socktype, result->ai_protocol); if(listenSocket == INVALID_SOCKET) { fprintf(stderr, "Error at socket(): %d\n", WSAGetLastError()); freeaddrinfo(result); WSACleanup(); return 1; } freeaddrinfo(result); iResult = bind(listenSocket, result->ai_addr, (int)result->ai_addrlen); if(iResult == SOCKET_ERROR) { fprintf(stderr, "bind failed with error: %d\n", WSAGetLastError()); closesocket(listenSocket); WSACleanup(); return 1; } if(listen(listenSocket, SOMAXCONN) == SOCKET_ERROR) { fprintf(stderr, "listen failed with error: %d\n", WSAGetLastError()); closesocket(listenSocket); WSACleanup(); return 1; } while (KeepRunning) { SOCKET clientSocket = accept(listenSocket, NULL, NULL); if (clientSocket == INVALID_SOCKET) { fprintf(stderr, "accept failed: %d\n", WSAGetLastError()); continue; } int iMode = 1; if (ioctlsocket(clientSocket, FIONBIO, &iMode) == SOCKET_ERROR) { fprintf(stderr, "ioctlsocket failed: %d\n", WSAGetLastError()); continue; } Sock sock; InitSock(&sock, (void*)clientSocket); ListPushBack(&serv.clientQueue, &sock); cnd_signal(&serv.newConn); } WSACleanup(); thrd_join(&connThread, NULL); thrd_join(&loopThread, NULL); cnd_destroy(&serv.newConn); cnd_destroy(&serv.updateLoop); DestroyList(&serv.requestQueue); DestroyList(&serv.clientQueue); DestroyConfig(&serv.conf); return 0; }