/** * Delete a session and its associated queues. * @param ses session */ static void unvme_session_delete(unvme_session_t* ses) { if (ses->id > 0) { pthread_spin_lock(&ses->iomem.lock); if (ses->iomem.size) { int i; for (i = 0; i < ses->iomem.count; i++) { (void) vfio_dma_free(ses->iomem.map[i]); } ses->iomem.size = ses->iomem.count = 0; free(ses->iomem.map); } pthread_spin_unlock(&ses->iomem.lock); pthread_spin_destroy(&ses->iomem.lock); } if (ses == ses->next) { DEBUG_FN("%x: adminq", unvme_dev.vfiodev->pci); unvme_adminq_delete(ses->queues); } else { DEBUG_FN("%x: q=%d-%d", unvme_dev.vfiodev->pci, ses->id, ses->id + ses->qcount -1); while (--ses->qcount >= 0) { unvme_queue_t* ioq = &ses->queues[ses->qcount]; if (ioq->ses) unvme_ioq_delete(ioq); } } LIST_DEL(unvme_dev.ses, ses); free(ses); }
void cleanup_context(struct tur_checker_context *ct) { pthread_mutex_destroy(&ct->lock); pthread_cond_destroy(&ct->active); pthread_spin_destroy(&ct->hldr_lock); free(ct); }
int main() { pthread_spinlock_t spinlock; struct sigaction act; /* Set up child thread to handle SIGALRM */ act.sa_flags = 0; act.sa_handler = sig_handler; sigfillset(&act.sa_mask); sigaction(SIGALRM, &act, 0); printf("main: attemp to lock an un-initialized spin lock\n"); printf("main: Send SIGALRM to me after 5 secs\n"); alarm(5); /* Attempt to lock an uninitialized spinlock */ rc = pthread_spin_lock(&spinlock); /* If we get here, call sig_handler() to check the return code of * pthread_spin_lock() */ sig_handler(); /* Unlock spinlock */ pthread_spin_unlock(&spinlock); /* Destroy spinlock */ pthread_spin_destroy(&spinlock); return PTS_PASS; }
int xwork_fini (struct xwork *xwork, int stop) { int i = 0; int ret = 0; void *tret = 0; pthread_mutex_lock (&xwork->mutex); { xwork->stop = (xwork->stop || stop); pthread_cond_broadcast (&xwork->cond); } pthread_mutex_unlock (&xwork->mutex); for (i = 0; i < xwork->count; i++) { pthread_join (xwork->cthreads[i], &tret); tdbg ("CThread id %ld returned %p\n", xwork->cthreads[i], tret); } if (debug) { assert (xwork->rootjob->refcnt == 1); dirjob_ret (xwork->rootjob, 0); } if (stats) pthread_spin_destroy(&stats_lock); return ret; }
static int do_test (void) { pthread_spinlock_t s; if (pthread_spin_init (&s, PTHREAD_PROCESS_PRIVATE) != 0) { puts ("spin_init failed"); return 1; } if (pthread_spin_lock (&s) != 0) { puts ("spin_lock failed"); return 1; } if (pthread_spin_unlock (&s) != 0) { puts ("spin_unlock failed"); return 1; } if (pthread_spin_destroy (&s) != 0) { puts ("spin_destroy failed"); return 1; } return 0; }
int main() { pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE); lockandunlock(); pthread_spin_destroy(&lock); }
PADclose() { while (!ev_fifo.empty()) ev_fifo.pop(); mutex_WasInit = false; pthread_spin_destroy(&mutex_KeyEvent); _PADclose(); }
spinlock::~spinlock() { #ifdef VOGL_BUILD_DEBUG VOGL_ASSERT(!m_in_lock); #endif pthread_spin_destroy(&m_spinlock); }
Internal::~Internal(){ #ifdef INTERNAL_USE_SPINLOCKS pthread_spin_destroy(&_spin); #else pthread_mutex_destroy(&_mutex); pthread_cond_destroy(&_cond); #endif }
int init_pipe(struct pipe* p, int n_dst, int q_depth, int buf_sz) { int free_bufs = n_dst * q_depth; struct pipe_elem* msg_all = (struct pipe_elem*)malloc( free_bufs * (sizeof(msg_all[0]) + buf_sz)); void* buf_ptr; int def_dst_n, i; // allocate bufs if (!msg_all) return -1; p->priv = (void*)msg_all; // initialize src if (init_queue(&p->src, free_bufs)) goto free_buf; // initialize dst def_dst_n = sizeof(p->_dst) / sizeof(p->_dst[0]); p->dst = n_dst < def_dst_n ? &p->_dst[0] : (struct queue*)malloc(n_dst * sizeof(p->dst[0])); if (!p->dst) goto free_src; for (i = 0; i < n_dst; i++) { if (init_queue(&p->dst[i], q_depth)) goto free_dst; } // init spinlock if (pthread_spin_init(&p->lock, PTHREAD_PROCESS_PRIVATE)) goto free_dst; // push buffers onto src buf_ptr = (void*)&msg_all[free_bufs]; for (i = 0; i < free_bufs; i++) { msg_all[i].buf = buf_ptr; msg_all[i].seq = 0; msg_all[i].ref_cnt = 0; buf_ptr += buf_sz; assert(!enqueue(&p->src, &msg_all[i])); } p->n_dst = n_dst; return 0; free_dst : for (i--; i >= 0; i--) close_queue(&p->dst[i]); free_src : close_queue(&p->src); free_buf : free(msg_all); destroy_lock : pthread_spin_destroy(&p->lock); return -1; }
HawkSpinLock::~HawkSpinLock() { if (m_pSpinLock) { pthread_spin_destroy((pthread_spinlock_t*)m_pSpinLock); HawkFree(m_pSpinLock); m_pSpinLock = 0; } }
void dirjob_free (struct dirjob *job) { assert (list_empty (&job->list)); pthread_spin_destroy (&job->lock); free (job->dirname); free (job); }
void thread_context_destroy(struct netsniff_ng_thread_context * thread_ctx) { assert(thread_ctx); pthread_attr_destroy(&thread_ctx->thread_attr); pthread_mutex_destroy(&thread_ctx->wait_mutex); pthread_cond_destroy(&thread_ctx->wait_cond); pthread_spin_destroy(&thread_ctx->config_lock); }
bool spinlock_destroy(spinlock_t *lock) { const int err = pthread_spin_destroy(lock); if (err) { error("spinlock error: %s", errno_error(err)); return false; } return true; }
void nk_port_destroy(nk_port *port) { if (!port) { return; } assert(nk_msg_port_empty(&port->msgs)); assert(nk_schob_runq_empty(&port->thds)); pthread_spin_destroy(&port->lock); nk_freelist_free(&port->host->port_freelist, port); }
int _starpu_spin_destroy(starpu_spinlock_t *lock) { #ifdef HAVE_PTHREAD_SPIN_LOCK return pthread_spin_destroy(&lock->lock); #else /* we don't do anything */ return 0; #endif }
void counter_destroy(Counter *counter) { #ifdef HAVE_PTHREAD_SPINLOCK_T pthread_spin_destroy(&counter->lock); #else mutex_destroy(counter->lock); #endif gw_free(counter); }
void core_lock_destroy(struct core_lock *self) { #if defined(CORE_LOCK_USE_COMPARE_AND_SWAP) self->lock = CORE_LOCK_UNLOCKED; #elif defined(CORE_LOCK_USE_SPIN_LOCK) pthread_spin_destroy(&self->lock); #elif defined(CORE_LOCK_USE_MUTEX) pthread_mutex_destroy(&self->lock); #endif }
/** * Remove resources for the tree. * * @param root root of the tree */ void tree_fini(struct bst_node ** root) { /* TODO: Free any global variables you used for the BST */ pthread_spin_destroy(&lock_cg); if (root != NULL) free(root); }
void PMR_counter_destroy_lock(counter_t *counter) { #ifndef DISABLE_PTHREADS #ifdef NOSPINLOCKS pthread_mutex_destroy(&counter->lock); #else pthread_spin_destroy(&counter->lock); #endif #endif }
//テスト int main(const int argc, const char* argv[]) { //スピンロック生成 pthread_spin_init(&s_lock, PTHREAD_PROCESS_PRIVATE);//単独プロセス専用 // pthread_spin_init(&s_lock, PTHREAD_PROCESS_SHARED);//プロセス間で共有 //スレッド作成 static const int THREAD_NUM = 3; pthread_t pth[THREAD_NUM]; { pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setstacksize(&attr, 1024);//スタックサイズ指定 pthread_create(&pth[0], &attr, threadFunc, (void*)"太郎"); pthread_create(&pth[1], &attr, threadFunc, (void*)"次郎"); pthread_create(&pth[2], &attr, threadFunc, (void*)"三郎"); } //スレッド終了待ち for(int i = 0; i < THREAD_NUM; ++i) { pthread_join(pth[i], NULL); } //スピにロックの取得と解放を大量に実行して時間を計測 { struct timeval begin; gettimeofday(&begin, NULL); static const int TEST_TIMES = 10000000; for (int i = 0; i < TEST_TIMES; ++i) { pthread_spin_lock(&s_lock); pthread_spin_unlock(&s_lock); } struct timeval end; gettimeofday(&end, NULL); struct timeval duration; if( end.tv_usec >= begin.tv_usec) { duration.tv_sec = end.tv_sec - begin.tv_sec; duration.tv_usec = end.tv_usec - begin.tv_usec; } else { duration.tv_sec = end.tv_sec - begin.tv_sec - 1; duration.tv_usec = 1000000 - begin.tv_usec + end.tv_usec; } printf("Spinlock * %d = %d.%06d sec\n", TEST_TIMES, duration.tv_sec, duration.tv_usec); } //スピンロック破棄 pthread_spin_destroy(&s_lock); return EXIT_SUCCESS; }
int main(int argc, char *argv[]) { long nproc = 0; long i; pthread_t *threads; if (argc != 1) { fprintf(stderr, "Usage: %s\n", argv[0]); return 1; } nproc = sysconf(_SC_NPROCESSORS_ONLN); if (nproc < 0) { perror("sysconf"); return 1; } #if defined _USE_MUTEX pthread_mutex_init(&mutex, NULL); #elif defined _USE_SPIN pthread_spin_init(&spinlock, 0); #endif threads = malloc(sizeof(pthread_t) * nproc); if (threads == NULL) { perror("malloc"); return 1; } printf("Starting %ld threads...\n", nproc); for (i = 0; i < nproc; i++) { if (pthread_create(&threads[i], NULL, incrementer, (void *)&i)) { perror("pthread_create"); nproc = i; break; } } for (i = 0; i < nproc; i++) { pthread_join(threads[i], NULL); } free(threads); printf("global_int actual value: %d\n", global_int); printf("global_int expected value: %d\n", (int)(INC_TO * nproc)); #if defined _USE_MUTEX pthread_mutex_destroy(&mutex); #elif defined _USE_SPIN pthread_spin_destroy(&spinlock); #endif return 0; }
/** check if OK, free struct */ void checklock_destroy(enum check_lock_type type, struct checked_lock** lock, const char* func, const char* file, int line) { const size_t contention_interest = 1; /* promille contented locks */ struct checked_lock* e; if(!lock) return; e = *lock; if(!e) return; checktype(type, e, func, file, line); /* check if delete is OK */ acquire_locklock(e, func, file, line); if(e->hold_count != 0) lock_error(e, func, file, line, "delete while locked."); if(e->wait_count != 0) lock_error(e, func, file, line, "delete while waited on."); prot_check(e, func, file, line); *lock = NULL; /* use after free will fail */ LOCKRET(pthread_mutex_unlock(&e->lock)); /* contention, look at fraction in trouble. */ if(e->history_count > 1 && 1000*e->contention_count/e->history_count > contention_interest) { log_info("lock created %s %s %d has contention %u of %u (%d%%)", e->create_func, e->create_file, e->create_line, (unsigned int)e->contention_count, (unsigned int)e->history_count, (int)(100*e->contention_count/e->history_count)); } /* delete it */ LOCKRET(pthread_mutex_destroy(&e->lock)); prot_clear(e); /* since nobody holds the lock - see check above, no need to unlink * from the thread-held locks list. */ switch(e->type) { case check_lock_mutex: LOCKRET(pthread_mutex_destroy(&e->u.mutex)); break; case check_lock_spinlock: LOCKRET(pthread_spin_destroy(&e->u.spinlock)); break; case check_lock_rwlock: LOCKRET(pthread_rwlock_destroy(&e->u.rwlock)); break; default: log_assert(0); } memset(e, 0, sizeof(struct checked_lock)); free(e); }
static void my_finit_hook (void) { pthread_spin_lock(&lock); /* Restore all old hooks */ __malloc_hook = old_malloc_hook; __realloc_hook = old_realloc_hook; __free_hook = old_free_hook; printf("Memtool finit!\n"); pthread_spin_unlock(&lock); pthread_spin_destroy(&lock); }
/** * Destroy firewall instance. * @param[in] fwd Firewall handle. */ void zfwall_destroy(struct zfirewall *fire) { pthread_spin_destroy(&fire->lock); for (int proto = 0; proto < PROTO_MAX; proto++) { for (int rule = 0; rule < PORT_MAX; rule++) { utarray_done(&fire->rules[proto][rule]); } } free(fire); }
static void nk_thd_destroy(nk_thd *t) { nk_hostthd *hostthd = nk_hostthd_self(); assert(hostthd != NULL); nk_host *host = hostthd->host; pthread_mutex_lock(&nk_thd_stack_freelist_mutex); nk_freelist_free(&nk_thd_stack_freelist, t->stack); pthread_mutex_unlock(&nk_thd_stack_freelist_mutex); pthread_spin_destroy(&t->running_lock); nk_schob_destroy(&t->schob); nk_freelist_free(&host->thd_freelist, t); }
void KmaClose(void) { if(fdKMA < 0) { printf("fdKMA is not initialized. please call Init() first\n"); return; } CancelAllTraceFunc(); pthread_spin_destroy(&traceFuncArrayLock); close(fdKMA); return; }
static int aio_socket_release(struct epoll_context* ctx) { if( 0 == __sync_sub_and_fetch_4(&ctx->ref, 1) ) { pthread_spin_destroy(&ctx->locker); #if defined(DEBUG) || defined(_DEBUG) memset(ctx, 0xCC, sizeof(*ctx)); #endif free(ctx); } return 0; }
void close_pipe(struct pipe* p) { int i; for (i = 0; i < p->n_dst; i++) close_queue(&p->dst[i]); if (p->dst != &p->_dst[0]) free(p->dst); close_queue(&p->src); free(p->priv); pthread_spin_destroy(&p->lock); }
int main(void) { int rc; pthread_spinlock_t spinlock; struct sigaction act; /* Set up child thread to handle SIGALRM */ act.sa_flags = 0; act.sa_handler = sig_handler; sigfillset(&act.sa_mask); sigaction(SIGALRM, &act, 0); if (pthread_spin_init(&spinlock, PTHREAD_PROCESS_PRIVATE) != 0) { printf("main: Error at pthread_spin_init()\n"); return PTS_UNRESOLVED; } printf("main: attempt spin lock\n"); /* We should get the lock */ if (pthread_spin_lock(&spinlock) != 0) { printf ("Test FAILED: main cannot get spin lock when no one owns the lock\n"); return PTS_FAIL; } printf("main: acquired spin lock\n"); printf("main: send SIGALRM to me after 2 secs\n"); alarm(2); printf("main: re-lock spin lock\n"); rc = pthread_spin_lock(&spinlock); if (rc == EDEADLK) { printf ("main: correctly got EDEADLK when re-locking the spin lock\n"); printf("Test PASSED\n"); } else { printf("main: get return code: %d , %s\n", rc, strerror(rc)); printf ("Test PASSED: *Note: Did not return EDEADLK when re-locking a spinlock already in use, but standard says 'may' fail\n"); } /* Unlock spinlock */ pthread_spin_unlock(&spinlock); /* Destroy spinlock */ pthread_spin_destroy(&spinlock); return PTS_PASS; }