/** * Delete the server. * @serv: The server. */ void web_serv_delete(struct web_serv_t *serv) { sys_task_delete(serv->task); sys_mutex_destroy(&serv->sync); sys_mutex_destroy(&serv->lock); web_client_destroy(serv->client); free(serv); }
error_code sys_lwmutex_destroy(ppu_thread& ppu, vm::ptr<sys_lwmutex_t> lwmutex) { sysPrxForUser.trace("sys_lwmutex_destroy(lwmutex=*0x%x)", lwmutex); if (g_cfg.core.hle_lwmutex) { return sys_mutex_destroy(lwmutex->sleep_queue); } // check to prevent recursive locking in the next call if (lwmutex->vars.owner.load() == ppu.id) { return CELL_EBUSY; } // attempt to lock the mutex if (error_code res = sys_lwmutex_trylock(ppu, lwmutex)) { return res; } // call the syscall if (error_code res = _sys_lwmutex_destroy(lwmutex->sleep_queue)) { // unlock the mutex if failed sys_lwmutex_unlock(ppu, lwmutex); return res; } // deleting succeeded lwmutex->vars.owner.release(lwmutex_dead); return CELL_OK; }
void sys_threadpool_destroy(sys_threadpool *pool) { size_t i; if (!pool) return; pool->shutdown = true; sys_threadpool_wait_all(pool, UINT32_MAX); sys_msleep(10); sys_tls_free_key(pool->worker_key); for (i = 0; i < pool->workers.count; ++i) sys_thread_destroy(((sys_worker *)rt_array_get(&pool->workers, i))->thread); rt_array_release(&pool->workers); rt_array_release(&pool->active_tasks); rt_queue_release(&pool->task_queue); sys_cond_var_destroy(pool->task_notify); sys_mutex_destroy(pool->task_mutex); free(pool); }
void gsiDeleteCriticalSection(GSICriticalSection *theCrit) { int ret; ret = sys_mutex_destroy(*theCrit); if (ret != CELL_OK) { gsDebugFormat(GSIDebugCat_Common, GSIDebugType_Misc, GSIDebugLevel_WarmError, "Failed to delete critical section: %d\r\n", ret); } }
/** * Delete a communication structure. * @comm: The communication structure. */ void amp_comm_delete(struct amp_comm_t *comm) { struct inst_t *inst; while((inst = comm->inst) != NULL) { comm->inst = inst->next; amp_midi_close(inst->midi); free(inst); } sys_mutex_destroy(&comm->lock); free(comm); }
RJ_API void rj_m_conn_destroy(rj_net_m_conn_h handle) { rj_net_multi_conn_t *p_m_conn = (rj_net_multi_conn_t *)(handle); assert (NULL != p_m_conn); if (NULL != p_m_conn) { while(0 < rj_list_size(p_m_conn->conn_list)) { rj_net_conn_h net_conn = (rj_net_conn_h)(rj_list_pop_front(p_m_conn->conn_list)); assert (NULL != net_conn); rj_conn_destroy(net_conn); } rj_list_destroy(p_m_conn->conn_list); sys_mutex_destroy(p_m_conn->p_sys_mutex); sys_free(p_m_conn);//delete p_m_conn; } }
sys_threadpool * sys_threadpool_create(uint32_t num_workers) { sys_threadpool *pool = (sys_threadpool *)calloc(1, sizeof(*pool)); sys_worker *worker = NULL; size_t i; if (!pool) return NULL; pool->task_mutex = sys_mutex_create(); pool->task_notify = sys_cond_var_create(); pool->num_workers = num_workers; pool->shutdown = false; if (pool->num_workers <= 0) { if ((pool->num_workers = sys_cpu_count()) <= 0) { log_entry(THREADPOOL_MODULE, LOG_WARNING, "Failed to determine processor count. Limiting server to one thread. To avoid this, specify the number of threads"); pool->num_workers = 1; } } if (rt_array_init(&pool->workers, pool->num_workers, sizeof(sys_worker)) != SYS_OK) goto free_task; if (rt_array_init(&pool->active_tasks, pool->num_workers, sizeof(sys_task *)) != SYS_OK) goto free_workers; if (rt_queue_init(&pool->task_queue, (size_t)pool->num_workers * 2, sizeof(sys_task)) != SYS_OK) goto free_active_tasks; pool->worker_key = sys_tls_alloc_key(); rt_array_fill(&pool->workers); for (i = 0; i < pool->num_workers; ++i) { worker = rt_array_get(&pool->workers, i); worker->id = i; worker->idle = true; worker->pool = pool; worker->thread = sys_thread_create(_threadpool_worker_proc); sys_thread_start(worker->thread, worker); sys_thread_detach(worker->thread); } return pool; free_active_tasks: rt_array_release(&pool->active_tasks); free_workers: rt_array_release(&pool->workers); free_task: sys_mutex_destroy(pool->task_mutex); sys_cond_var_destroy(pool->task_notify); free(pool); return NULL; }
CellMutex::~CellMutex () { sys_mutex_destroy(Mutex); }