/** * @brief Unlock of read * * @details * <p> Decreases a reading count. </p> * * <p> When write_lock had done after read_lock, it continues by read_unlock * if the reading count was 1 (read_unlock makes the count to be zero). </p> */ void readUnlock() const { std::unique_lock<std::mutex> uk((std::mutex&)read_mtx); //차감 전 이미 0 (과도한 readUnlock 수행) 은 안 됨 if (reading != 0 && --((size_t&)reading) == 0) ((std::condition_variable&)cv).notify_all(); };
/** * @brief Lock on writing * * @details * <p> Changes writing flag to true. </p> * * <p> If another write_lock or read_lock is on a progress, wait until them to be unlocked. </p> * * \li Writing can be done by only a section at once. * \li Writing can't be done when reading. * * @note You've to call write_unlock when writing work was terminated. */ void writeLock() { std::unique_lock<std::mutex> uk(write_mtx_); while (writing_ == true || readers_count_ > 0) write_cv_.wait(uk); writing_ = true; };
void Semaphore::lock() { unique_lock<mutex> uk(*referMutex); while (locked->load() >= size->load()) cv->wait(uk); locked->operator++(); }
/** * @brief Lock on read * * @details * <p> Increases a reading count. </p> * <p> When write_lock is on a progress, wait until write_unlock to be called. </p> * * \li Reading can be done by multiple sections. * \li Reading can't be done when writing. * * @warning You've to call read_unlock when the reading work is terminated. */ void readLock() const { std::unique_lock<std::mutex> uk((std::mutex&)read_mtx); while (writing == true) ((std::condition_variable&)cv).wait(uk); ((size_t&)reading)++; };
/** * @brief Lock on writing * * @details * <p> Changes writing flag to true. </p> * * <p> If another write_lock or read_lock is on a progress, wait until them to be unlocked. </p> * * \li Writing can be done by only a section at once. * \li Writing can't be done when reading. * * @note You've to call write_unlock when writing work was terminated. */ void writeLock() { std::unique_lock<std::mutex> uk(read_mtx); while (reading > 0) cv.wait(uk); uk.unlock(); write_mtx.lock(); writing = true; };
/** * Add a newly connected remote client. * * When a {@link ClientDriver remote client} connects to this *server* {@link ExternalClientArray} object, * then this {@link ExternalClientArray} creates a child {@link ExternalSystem external client} object through * the {@link createExternalClient createExternalClient()} method and {@link insert inserts} it. * * @param driver A communicator for external client. */ virtual void addClient(std::shared_ptr<protocol::ClientDriver> driver) override final { std::shared_ptr<ExternalSystem> system(createExternalClient(driver)); if (system == nullptr) return; system->communicator_ = driver; { library::UniqueWriteLock uk(getMutex()); push_back(system); } driver->listen(system.get()); for (size_t i = 0; i < size(); i++) if (at(i) == system) { library::UniqueWriteLock uk(getMutex()); erase(begin() + i); break; } };
/** * @brief Unlock of read * * @details * <p> Decreases a reading count. </p> * * <p> When write_lock had done after read_lock, it continues by read_unlock * if the reading count was 1 (read_unlock makes the count to be zero). </p> */ void readUnlock() const { std::unique_lock<std::mutex> uk((std::mutex&)readers_count_mtx_); //차감 전 이미 0 (과도한 readUnlock 수행) 은 안 됨 if (readers_count_ != 0 && --((size_t&)readers_count_) == 0) { uk.unlock(); ((std::condition_variable&)read_cv_).notify_all(); ((std::condition_variable&)write_cv_).notify_all(); } };
/** * @brief Lock on read * * @details * <p> Increases a reading count. </p> * <p> When write_lock is on a progress, wait until write_unlock to be called. </p> * * \li Reading can be done by multiple sections. * \li Reading can't be done when writing. * * @warning You've to call read_unlock when the reading work is terminated. */ void readLock() const { // WAIT WRITE_UNLOCK std::unique_lock<std::mutex> uk((std::mutex&)read_mtx_); while (writing_ == true) ((std::condition_variable&)read_cv_).wait(uk); // PLUS NUMBER OF READERS ((std::mutex&)readers_count_mtx_).lock(); ((size_t&)readers_count_)++; ((std::mutex&)readers_count_mtx_).unlock(); };
/** * Send an {@link Invoke} message. * * @param invoke An {@link Invoke} message to send. */ virtual void sendData(std::shared_ptr<protocol::Invoke> invoke) { std::vector<std::thread> threads; library::UniqueReadLock uk(getMutex()); threads.reserve(this->size()); for (size_t i = 0; i < size(); i++) threads.emplace_back(&ExternalSystem::sendData, at(i).get(), invoke); uk.unlock(); for (auto it = threads.begin(); it != threads.end(); it++) it->join(); };
/* --------------------------------------------------------- INVOKE MESSAGE CHAIN --------------------------------------------------------- */ void _Complete_history(size_t uid) { std::unique_lock<std::mutex> uk(mtx_); //-------- // NEED TO REDEFINE START AND END TIME //-------- // NO SUCH HISTORY; THE PROCESS HAD DONE ONLY IN THIS MEDIATOR LEVEL. if (progress_list_.has(uid) == false) return; // COMPLETE THE HISTORY std::shared_ptr<slave::InvokeHistory> history = progress_list_.get(uid); history->complete(); // ERASE THE HISTORY ON PROGRESS LIST progress_list_.erase(uid); // REPORT THE HISTORY TO MASTER std::thread(&MediatorSystem::sendData, this, history->toInvoke()).detach(); };
void EHttpBasicAuthLogicHandler::doHandshake(EIoFilter::NextFilter* nextFilter) { logger->debug(__FILE__, __LINE__, " doHandshake()"); if (step > 0) { throw EProxyAuthException(__FILE__, __LINE__, "Authentication request already sent"); } // Send request sp<EHttpProxyRequest> req = dynamic_pointer_cast<EHttpProxyRequest>(request); EMap<EString*, EList<EString*>*>* headers = req->getHeaders(); EString uk(EHttpProxyConstants_USER_PROPERTY); EString* username = req->getProperties()->get(&uk); EString pw(EHttpProxyConstants_PWD_PROPERTY); EString* password = req->getProperties()->get(&pw); EString value("Basic " + createAuthorization(username->c_str(), password->c_str())); EAbstractAuthLogicHandler::addValueToHeader(headers, "Proxy-Authorization", value.c_str(), true); addKeepAliveHeaders(headers); writeRequest(nextFilter, req); step++; }
arma::mat ung_ssm::sample_model(const unsigned int predict_type, const unsigned int nsim) { arma::cube alpha(m, n, nsim); std::normal_distribution<> normal(0.0, 1.0); for (unsigned int i = 0; i < nsim; i++) { alpha.slice(i).col(0) = a1; for (unsigned int t = 0; t < (n - 1); t++) { arma::vec uk(k); for(unsigned int j = 0; j < k; j++) { uk(j) = normal(engine); } alpha.slice(i).col(t + 1) = C.col(t * Ctv) + T.slice(t * Ttv) * alpha.slice(i).col(t) + R.slice(t * Rtv) * uk; } } if (predict_type < 3) { arma::cube y(1, n, nsim); switch(distribution) { case 0: y.zeros(); break; case 1: for (unsigned int i = 0; i < nsim; i++) { for (unsigned int t = 0; t < n; t++) { y(0, t, i) = std::exp(xbeta(t) + D(t * Dtv) + arma::as_scalar(Z.col(t * Ztv).t() * alpha.slice(i).col(t))); } } break; case 2: for (unsigned int i = 0; i < nsim; i++) { for (unsigned int t = 0; t < n; t++) { double tmp = std::exp(xbeta(t) + D(t * Dtv) + arma::as_scalar(Z.col(t * Ztv).t() * alpha.slice(i).col(t))); y(0, t, i) = tmp / (1.0 + tmp); } } break; case 3: for (unsigned int i = 0; i < nsim; i++) { for (unsigned int t = 0; t < n; t++) { y(0, t, i) = std::exp(xbeta(t) + D(t * Dtv) + arma::as_scalar(Z.col(t * Ztv).t() * alpha.slice(i).col(t))); } } break; } if (predict_type == 1) { switch(distribution) { case 0: break; case 1: for (unsigned int i = 0; i < nsim; i++) { for (unsigned int t = 0; t < n; t++) { std::poisson_distribution<> poisson(u(t) * y(0, t, i)); if ((u(t) * y(0, t, i)) < poisson.max()) { y(0, t, i) = poisson(engine); } else { y(0, t, i) = std::numeric_limits<double>::quiet_NaN(); } } } break; case 2: for (unsigned int i = 0; i < nsim; i++) { for (unsigned int t = 0; t < n; t++) { std::binomial_distribution<> binomial(u(t), y(0, t, i)); y(0, t, i) = binomial(engine); } } break; case 3: for (unsigned int i = 0; i < nsim; i++) { for (unsigned int t = 0; t < n; t++) { std::negative_binomial_distribution<> negative_binomial(phi, phi / (phi + u(t) * y(0, t, i))); y(0, t, i) = negative_binomial(engine); } } break; } } return y; } return alpha; }
double ung_ssm::bsf_filter(const unsigned int nsim, arma::cube& alpha, arma::mat& weights, arma::umat& indices) { arma::uvec nonzero = arma::find(P1.diag() > 0); arma::mat L_P1(m, m, arma::fill::zeros); if (nonzero.n_elem > 0) { L_P1.submat(nonzero, nonzero) = arma::chol(P1.submat(nonzero, nonzero), "lower"); } std::normal_distribution<> normal(0.0, 1.0); for (unsigned int i = 0; i < nsim; i++) { arma::vec um(m); for(unsigned int j = 0; j < m; j++) { um(j) = normal(engine); } alpha.slice(i).col(0) = a1 + L_P1 * um; } std::uniform_real_distribution<> unif(0.0, 1.0); arma::vec normalized_weights(nsim); double loglik = 0.0; if(arma::is_finite(y(0))) { weights.col(0) = log_obs_density(0, alpha); double max_weight = weights.col(0).max(); weights.col(0) = arma::exp(weights.col(0) - max_weight); double sum_weights = arma::accu(weights.col(0)); if(sum_weights > 0.0){ normalized_weights = weights.col(0) / sum_weights; } else { return -std::numeric_limits<double>::infinity(); } loglik = max_weight + std::log(sum_weights / nsim); } else { weights.col(0).ones(); normalized_weights.fill(1.0 / nsim); } for (unsigned int t = 0; t < n; t++) { arma::vec r(nsim); for (unsigned int i = 0; i < nsim; i++) { r(i) = unif(engine); } indices.col(t) = stratified_sample(normalized_weights, r, nsim); arma::mat alphatmp(m, nsim); for (unsigned int i = 0; i < nsim; i++) { alphatmp.col(i) = alpha.slice(indices(i, t)).col(t); } for (unsigned int i = 0; i < nsim; i++) { arma::vec uk(k); for(unsigned int j = 0; j < k; j++) { uk(j) = normal(engine); } alpha.slice(i).col(t + 1) = C.col(t * Ctv) + T.slice(t * Ttv) * alphatmp.col(i) + R.slice(t * Rtv) * uk; } if ((t < (n - 1)) && arma::is_finite(y(t + 1))) { weights.col(t + 1) = log_obs_density(t + 1, alpha); double max_weight = weights.col(t + 1).max(); weights.col(t + 1) = arma::exp(weights.col(t + 1) - max_weight); double sum_weights = arma::accu(weights.col(t + 1)); if(sum_weights > 0.0){ normalized_weights = weights.col(t + 1) / sum_weights; } else { return -std::numeric_limits<double>::infinity(); } loglik += max_weight + std::log(sum_weights / nsim); } else { weights.col(t + 1).ones(); normalized_weights.fill(1.0/nsim); } } // constant part of the log-likelihood switch(distribution) { case 0 : loglik += arma::uvec(arma::find_finite(y)).n_elem * norm_log_const(phi); break; case 1 : { arma::uvec finite_y(find_finite(y)); loglik += poisson_log_const(y(finite_y), u(finite_y)); } break; case 2 : { arma::uvec finite_y(find_finite(y)); loglik += binomial_log_const(y(finite_y), u(finite_y)); } break; case 3 : { arma::uvec finite_y(find_finite(y)); loglik += negbin_log_const(y(finite_y), u(finite_y), phi); } break; } return loglik; }