Esempio n. 1
0
  /** Reserve some part of the pipe for reading

      \param[in] s is the number of element to reserve

      \param[out] rid is an iterator to a description of the
      reservation that has been done if successful

      \param[in] blocking specify if the call wait for the operation
      to succeed

      \return true if the reservation was successful
  */
  bool reserve_read(std::size_t s,
                    rid_iterator &rid,
                    bool blocking = false)  {
    // Lock the pipe to avoid being disturbed
    std::unique_lock<std::mutex> ul { cb_mutex };

    TRISYCL_DUMP_T("Before read reservation cb.size() = " << cb.size()
                   << " size() = " << size());
    if (s == 0)
      // Empty reservation requested, so nothing to do
      return false;

    if (blocking)
      /* If in blocking mode, wait for enough elements to read in the
         pipe for the reservation. This condition can change when a
         write is done */
      write_done.wait(ul, [&] { return s <= size(); });
    else if (s > size())
      // Not enough elements to read in the pipe for the reservation
      return false;

    // Compute the location of the first element of the reservation
    auto first = cb.begin() + read_reserved_frozen;
    // Increment the number of frozen elements
    read_reserved_frozen += s;
    /* Add a description of the reservation at the end of the
       reservation queue */
    r_rid_q.emplace_back(first, s);
    // Return the iterator to the last reservation descriptor
    rid = r_rid_q.end() - 1;
    TRISYCL_DUMP_T("After reservation cb.size() = " << cb.size()
                   << " size() = " << size());
    return true;
  }
Esempio n. 2
0
void Enter(Activity *activity) {
	if (current) {
		stack.emplace_back(current);
	}
	current = activity;
	current->dispatchStart();
}
Esempio n. 3
0
 S4() {
    for(int i = 0; i < 6; ++i) {
       m_s1.emplace_back();
       m_s2.emplace_back();
       m_s3.emplace_back();
    }
 }
Esempio n. 4
0
static inline void propagate_age_update(Cfg& conf, std::deque<Cfg>& tmpres, std::size_t dst) {
	// here we propagate an age field update to all pointers that are equal
	// and thus experience the update too => only for age updates of next fields

	// split to find truly equal pointers
	auto shape_split = disambiguate(*conf.shape, dst);

	for (Shape* s : shape_split) {
		tmpres.emplace_back(Cfg(conf, s));
		Cfg& config = tmpres.back();

		// pointer equal to dst => experiences age update too
		for (std::size_t i = 0; i < s->size(); i++) {
			if (i == dst) continue;
			if (s->test(i, dst, EQ)) {
				#if CAS_OVERAPPROXIMATE_AGE_PROPAGATION
					// overapproximation: drop age relation of pointers that observe the age assignemnt
					for (std::size_t j = 0; j < s->size(); j++)
						for (bool b : {false, true})
							config.ages->set(j, b, i, true, AgeRel::BOT);
				#else
					mk_next_age_equal(config, i, dst, true);
				#endif
			}
		}
	}

	// the shape/ages from conf may no longer be valid => overwrite the shape/ages
	conf.shape = std::move(tmpres.back().shape);
	conf.ages = std::move(tmpres.back().ages);
	tmpres.pop_back();
}
Esempio n. 5
0
int Cursor::Next(const size_t count, std::deque<nx::String>& buf)
{
	int rs = 0;
	if (isShared())
	{
		if (extra_state_ && extra_state_->IsReady())
		{  // +extra with mixing
			std::string rs = extra_state_->Get(extra_delim_);
			buf.emplace_back(rs.begin(), rs.end());
			++(*extra_state_);
			rs = 1;
		}
		else
		{
				std::deque<nx::String> tmpbuf;
				rs = do_next(count * shared_total_, tmpbuf);
				if(rs >= 0)
					for(size_t i = 0, j = shared_curr_ - 1; i < count && j < tmpbuf.size();
							++i, j = shared_curr_ - 1 + shared_total_*i )
					{
						buf.push_back(tmpbuf[j]);
					}
		}
	}
	else
	{
		++(*extra_state_);
		rs = do_next(count, buf);
	}
	return rs;
}
Esempio n. 6
0
void createPlugins(MyPluginFactory& factory, const std::vector<std::string>& availablePlugins, std::deque<MyPlugin>& plugins)
{
    for(const auto& pluginName : availablePlugins)
    {
        plugins.emplace_back(factory.instance(pluginName));
    }
}
Esempio n. 7
0
void run_on_main_thread(std::function<void()> &func) {

    {
       std::unique_lock<std::mutex> lock(main_thread_mutex);
       main_func.emplace_back(func);
    }
    main_thread_cv.notify_all();
    std::unique_lock<std::mutex> lock(main_thread_mutex);
    main_thread_cv.wait(lock, []{ return main_done || main_func.empty(); });
}
Esempio n. 8
0
 /** Enqueue a work item */
 bool Enqueue(WorkItem* item)
 {
     boost::unique_lock<boost::mutex> lock(cs);
     if (queue.size() >= maxDepth) {
         return false;
     }
     queue.emplace_back(std::unique_ptr<WorkItem>(item));
     cond.notify_one();
     return true;
 }
Esempio n. 9
0
	void element_is_ready() {
		std::unique_lock<std::mutex> guard(m_lock);
		m_elements.emplace_back(std::move(m_current));
		m_current.reset(new element);

		if (m_elements.size() > m_pool.size() * 2) {
			m_parser_wait.wait(guard, [&] {return m_elements.size() < m_pool.size();});
		}

		guard.unlock();
		m_pool_wait.notify_one();
	}
    // ------------------------------------------------------------------------
    void addAndSetTime(uint32_t ping, uint64_t server_time)
    {
        if (m_synchronised.load() == true)
            return;

        if (m_force_set_timer.load() == true)
        {
            m_force_set_timer.store(false);
            m_synchronised.store(true);
            STKHost::get()->setNetworkTimer(server_time + (uint64_t)(ping / 2));
            return;
        }

        const uint64_t cur_time = StkTime::getMonoTimeMs();
        // Discard too close time compared to last ping
        // (due to resend when packet loss)
        // 10 packets per second as seen in STKHost
        const uint64_t frequency = (uint64_t)((1.0f / 10.0f) * 1000.0f) / 2;
        if (!m_times.empty() &&
            cur_time - std::get<2>(m_times.back()) < frequency)
            return;

        // Take max 20 averaged samples from m_times, the next addAndGetTime
        // is used to determine that server_time if it's correct, if not
        // clear half in m_times until it's correct
        if (m_times.size() >= 20)
        {
            uint64_t sum = std::accumulate(m_times.begin(), m_times.end(),
                (uint64_t)0, [cur_time](const uint64_t previous,
                const std::tuple<uint32_t, uint64_t, uint64_t>& b)->uint64_t
                {
                    return previous + (uint64_t)(std::get<0>(b) / 2) +
                        std::get<1>(b) + cur_time - std::get<2>(b);
                });
            const int64_t averaged_time = sum / 20;
            const int64_t server_time_now = server_time + (uint64_t)(ping / 2);
            int difference = (int)std::abs(averaged_time - server_time_now);
            if (std::abs(averaged_time - server_time_now) <
                UserConfigParams::m_timer_sync_difference_tolerance)
            {
                STKHost::get()->setNetworkTimer(averaged_time);
                m_times.clear();
                m_force_set_timer.store(false);
                m_synchronised.store(true);
                Log::info("NetworkTimerSynchronizer", "Network "
                    "timer synchronized, difference: %dms", difference);
                return;
            }
            m_times.erase(m_times.begin(), m_times.begin() + 10);
        }
        m_times.emplace_back(ping, server_time, cur_time);
    }
Esempio n. 11
0
    void
    append(Args&&... args) {
        static_assert(
            std::is_same<typename Event::tag, Tag>::value,
            "message protocol is not compatible with this message queue"
        );

        if(!upstream_) {
            return operations.emplace_back(aux::make_frozen<Event>(std::forward<Args>(args)...));
        }

        upstream_->send<Event>(std::forward<Args>(args)...);
    }
Esempio n. 12
0
void ProfileDrawer::DbgTimingInfo(DbgTimingInfoType type, const spring_time start, const spring_time end)
{
	if (!IsEnabled())
		return;

	switch (type) {
		case TIMING_VIDEO: {
			vidFrames.emplace_back(start, end);
		} break;
		case TIMING_SIM: {
			simFrames.emplace_back(start, end);
		} break;
		case TIMING_GC: {
			lgcFrames.emplace_back(start, end);
		} break;
		case TIMING_SWAP: {
			swpFrames.emplace_back(start, end);
		} break;
		case TIMING_UNSYNCED: {
			uusFrames.emplace_back(start, end);
		} break;
	}
}
Esempio n. 13
0
 result_type
 traverse(std::conditional_t< reassmble, ast::expression &&, ast::expression const & > _input)
 { // if reassmble is true, then input is taken apart, then reassembled
     assert(output_.empty());
     if (_input.rest_.empty()) {
         return dispatcher_(std::move(_input.first_));
     } else if (_input.rest_.size() == 1) {
         auto & operation_ = _input.rest_.back();
         return dispatcher_(std::move(_input.first_),
                            operation_.operator_,
                            std::move(operation_.operand_));
     } else {
         //output_.reserve(_input.rest_.size() * 2 + 1); // total number of operators and operands
         std::stack< aggregate_wrapper< lhs_op > > lhs_op_;
         for (auto & operation_ : _input.rest_) {
             size_type const precedence_ = ast::precedence(operation_.operator_);
             while (!lhs_op_.empty()) {
                 lhs_op const & top_ = lhs_op_.top();
                 if (ast::precedence(top_.operator_) < precedence_) {
                     break;
                 }
                 output_.emplace_back(top_.lhs_, top_.operator_, output_.size());
                 lhs_op_.pop();
             }
             lhs_op_.emplace(output_.size(), operation_.operator_);
             output_.emplace_back(&operation_.operand_);
         }
         while (!lhs_op_.empty()) {
             lhs_op const & top_ = lhs_op_.top();
             output_.emplace_back(top_.lhs_, top_.operator_, output_.size());
             lhs_op_.pop();
         }
         output_.emplace_front(&_input.first_);
         return operator () (output_.back());
     }
 }
Esempio n. 14
0
	std::unique_ptr<ui8[]> getCachedFile(ResourceID rid)
	{
		for(auto & file : cache)
		{
			if (file.name == rid)
				return file.getCopy();
		}
		// Still here? Cache miss
		if (cache.size() > cacheSize)
			cache.pop_front();

		auto data =  CResourceHandler::get()->load(rid)->readAll();

		cache.emplace_back(std::move(rid), data.second, std::move(data.first));

		return cache.back().getCopy();
	}
Esempio n. 15
0
	ComponentType& addComponent(Args&&... args)
	{
		static_assert(std::is_base_of<NodeComponent, ComponentType>::value,
		              "ComponentType must inherit from NodeComponent.");
		assert(!hasComponent<ComponentType>() &&
		       "SceneNode::addComponent component of that type already exists.");

		ComponentType* component{
		    new ComponentType{std::forward<Args>(args)...}};
		component->parent = this;
		components.emplace_back(std::unique_ptr<NodeComponent>{component});

		componentArray[getComponentTypeId<ComponentType>()] = component;
		componentBitset[getComponentTypeId<ComponentType>()] = true;

		return *component;
	}
Esempio n. 16
0
void	Arbitre::checkOnEat(Vector<int> const &pos, Vector<int> const &nb, int color, char const * const *map, std::deque<Vector<Vector<int>>> &coords)
{
	Vector<int> tmpx, tmpy, tmpz;
	int ocolor;

	ocolor = color == WHITE ? BLACK : WHITE;
	tmpx = pos + nb;
	tmpy = tmpx + nb;
	tmpz = tmpy + nb;
	if (tmpx.x >= 0 && tmpy.x >= 0 && tmpz.x >= 0
		&& tmpx.x < 19 && tmpy.x < 19 && tmpz.x < 19
		&& tmpx.y >= 0 && tmpy.y >= 0 && tmpz.y >= 0
		&& tmpx.y < 19 && tmpy.y < 19 && tmpz.y < 19
		&& map[tmpx.y][tmpx.x] == ocolor
		&& map[tmpy.y][tmpy.x] == ocolor
		&& map[tmpz.y][tmpz.x] == color)
		coords.emplace_back(tmpx, tmpy);
}
Esempio n. 17
0
    void do_resolve (std::vector <std::string> const& names,
        HandlerType const& handler, CompletionCounter)
    {
        assert (! names.empty());

        if (m_stop_called == false)
        {
            m_work.emplace_back (names, handler);

            JLOG(m_journal.debug()) <<
                "Queued new job with " << names.size() <<
                " tasks. " << m_work.size() << " jobs outstanding.";

            if (m_work.size() > 0)
            {
                m_io_service.post (m_strand.wrap (std::bind (
                    &ResolverAsioImpl::do_work, this,
                        CompletionCounter (this))));
            }
        }
    }
Esempio n. 18
0
void
TTreeBase::ukkonenPush(
    std::deque<TUkkonenBuildCursor>& cursors,
    size_t position
) {
    cursors.emplace_back(TUkkonenBuildCursor(&rootEdge));
    TNode* nodeForLink = nullptr;

    while (cursors.front().deleted) {
        cursors.pop_front();
    }
    //*dbg*/ size_t counter = 0;
    for (auto& cursor : cursors) {
        if (cursor.deleted) {
            //*dbg*/ std::cerr << counter++ << ": skip deleted cursor\n";
            /*dbg*/ throw TSimpleException("impossible situation");
            continue;
        }
        //*dbg*/ else {
        //*dbg*/     std::cerr << counter++ << ": cursor: \n";
        //*dbg*/ }
        /*dbg*/ std::cerr << "step " << cursor.edge->subString.str << std::endl;
        /*dbg*/ std::cerr << "step edge ptr " << cursor.edge << std::endl;
        int stepType = cursor.step(position);
        /*dbg*/ std::cerr << "step: " << stepType << "\n\n";

        if (stepType > 1) {
            TNode* currentNode = cursor.edge->parentNode;
            if (nodeForLink != nullptr && nodeForLink->suffixLink == nullptr) {
                //*dbg*/ std::cerr << "link\n";
                nodeForLink->suffixLink = currentNode;
            }
            nodeForLink = currentNode;
        }
        if (stepType == 2) {
            cursor.deleted = true;
        }
    }
}
Esempio n. 19
0
    void add_msg_string(std::string &&msg, game_message_type const type) {
        if (msg.length() == 0) {
            return;
        }
        // hide messages if dead
        if (g->u.is_dead_state()) {
            return;
        }

        if (type == m_debug && !debug_mode) {
            return;
        }
        
        if (coalesce_messages(msg, type)) {
            return;
        }

        while (messages.size() > 255) {
            messages.pop_front();
        }

        messages.emplace_back(remove_color_tags(std::move(msg)), type);
    }
Esempio n. 20
0
  /** Reserve some part of the pipe for writing

      \param[in] s is the number of element to reserve

      \param[out] rid is an iterator to a description of the
      reservation that has been done if successful

      \param[in] blocking specify if the call wait for the operation
      to succeed

      \return true if the reservation was successful
  */
  bool reserve_write(std::size_t s,
                     rid_iterator &rid,
                     bool blocking = false)  {
    // Lock the pipe to avoid being disturbed
    std::unique_lock<std::mutex> ul { cb_mutex };

    TRISYCL_DUMP_T("Before write reservation cb.size() = " << cb.size()
                   << " size() = " << size());
    if (s == 0)
      // Empty reservation requested, so nothing to do
      return false;

    if (blocking)
      /* If in blocking mode, wait for enough room in the pipe, that
         may be changed when a read is done. Do not use a difference
         here because it is only about unsigned values */
      read_done.wait(ul, [&] { return cb.size() + s <= capacity(); });
    else if (cb.size() + s > capacity())
      // Not enough room in the pipe for the reservation
      return false;

    /* If there is enough room in the pipe, just create default values
         in it to do the reservation */
    for (std::size_t i = 0; i != s; ++i)
      cb.push_back();
    /* Compute the location of the first element a posteriori since it
         may not exist a priori if cb was empty before */
    auto first = cb.end() - s;
    /* Add a description of the reservation at the end of the
       reservation queue */
    w_rid_q.emplace_back(first, s);
    // Return the iterator to the last reservation descriptor
    rid = w_rid_q.end() - 1;
    TRISYCL_DUMP_T("After reservation cb.size() = " << cb.size()
                   << " size() = " << size());
    return true;
  }
Esempio n. 21
0
void finished_with_buffer(std::shared_ptr<std::vector<unsigned char> > buffer) {
	if(buffer.unique()) {
		free_buffers.emplace_back(std::move(buffer));
	}
}
 void emplace(ARGS&&... args)
 {
   // Add to back
   Items.emplace_back(std::forward<ARGS>(args)...);
 }
Esempio n. 23
0
event_context::event_context()
{
	event_contexts.emplace_back();
}
 void push(ARG&& val)
 {
   // Add to back
   Items.emplace_back(std::forward<ARG>(val));
 }
Esempio n. 25
0
/// Process data from bitcoind daemon (esp. RPC getrawmempool for live transactions)
void daemonThreadFunc(BlockChain* blockChain)
{
	leveldb::WriteBatch batch;

	while (true)
	{
		std::this_thread::sleep_for(std::chrono::seconds(1));

		if (requestedQuit)
			break;

		if (!txCheck)
			continue;

		try
		{
			auto transactions = rpcClient->CallMethod("getrawmempool", Json::Value());

			BlockInfo blockInfo;
			Hash256 latestBlock;
			{
				boost::lock_guard<boost::mutex> guard(chainMutex);
				latestBlock = currentChain.back();

				auto blockInfoIt = blocks.find(latestBlock);
				if (blockInfoIt == blocks.end())
				{
					continue;
				}
				blockInfo = blockInfoIt->second;
			}

			if (pendingPreviousBlock != latestBlock)
			{
				pendingPreviousBlock = latestBlock;

				// Broadcast new block for live update
				Json::Value blockResult;
				blockResult["item"] = "block";
				convertBlock(blockResult, pendingPreviousBlock, blockInfo);
				websocket_server.broadcast_livetx(blockResult.toStyledString().c_str());

				{
					boost::lock_guard<boost::mutex> guard(pendingTransactionsMutex);
					pendingTransactionIndices.clear();
					pendingTransactions.clear();
					pendingTransactionsByAddress.clear();
				}
			}

			for (auto tx = transactions.begin(); tx != transactions.end(); ++tx)
			{
				Hash256 txHash;
				encodeHexString((uint8_t*) &txHash, 32, (*tx).asString(), true);

				batch.Clear();

				{
					// Already exists?
					boost::unique_lock<boost::mutex> guard(pendingTransactionsMutex);
					if (pendingTransactionIndices.find(txHash) != pendingTransactionIndices.end())
						continue;
				}

				{
					DbTransaction dbTx;

					Json::Value parameters(Json::arrayValue);
					parameters.append(*tx);
					auto rawTx = rpcClient->CallMethod("getrawtransaction", parameters);

					auto data = rawTx.asCString();
					auto bufferLength = strlen(data) / 2;

					llvm::SmallVector<uint8_t, 65536> buffer;
					buffer.resize(bufferLength);

					encodeHexString(buffer.begin(), bufferLength, data);

					BlockChain::BlockTransaction tx2;
					if (!blockChain->processSingleTransaction(buffer.begin(), bufferLength, tx2))
						assert("could not read tx" && false);

					assert(memcmp(tx2.transactionHash, &txHash, 32) == 0);
					uint64_t totalOutput = 0;
					bool needBroadcast = false;

					auto txIndex = dbHelper.txLoad(txHash, dbTx, NULL, NULL);
					if (txIndex == 0)
					{
						{
							boost::unique_lock<boost::mutex> guard(pendingTransactionsMutex);
							try
							{
								txIndex = processTransaction(batch, dbTx, tx2, time(NULL), false, &pendingTransactionIndices, &pendingTransactions);
							}
							catch (std::exception e)
							{
								batch.Clear();
								continue;
							}
						}

						needBroadcast = true;

						dbHelper.txSave(batch, txHash, dbTx);
						db->Write(leveldb::WriteOptions(), &batch);
					}

					{
						boost::unique_lock<boost::mutex> guard(pendingTransactionsMutex);
						pendingTransactionIndices[txHash] = pendingTransactions.size();
						pendingTransactions.emplace_back(txHash, dbTx);

						// lastPendingTransactions only holds last N items 
						if (lastPendingTransactions.size() >= lastPendingTransactionsSize)
							lastPendingTransactions.pop_front();

						lastPendingTransactions.emplace_back(txHash, dbTx);

						for (auto output = dbTx.outputs.begin(); output != dbTx.outputs.end(); ++output)
						{
							if (output->address.IsNull())
								continue;
							totalOutput += output->value;

							pendingTransactionsByAddress.emplace(output->address, pendingTransactions.size() - 1);
						}

						for (auto input = dbTx.inputs.begin(); input != dbTx.inputs.end(); ++input)
						{
							if (input->address.IsNull())
								continue;

							pendingTransactionsByAddress.emplace(input->address, pendingTransactions.size() - 1);
						}
					}

					if (needBroadcast)
					{
						Json::Value txResult;

						// Broadcast tx for live update
						txResult["item"] = "tx";
						txResult["output"] = (double)totalOutput;

						char timeBuffer[65];
						convertTime(dbTx.getBestTimeStamp(), timeBuffer, sizeof(timeBuffer));
						txResult["time"] = timeBuffer;

						txResult["coinage_destroyed"] = dbTx.coinAgeDestroyed / 86400.0;
						txResult["hash"] = *tx;

						websocket_server.broadcast_livetx(txResult.toStyledString().c_str());
					}
				}
			}
		}
		catch (std::exception e)
		{
			boost::lock_guard<boost::mutex> guard(pendingTransactionsMutex);
			pendingTransactionIndices.clear();
			pendingTransactions.clear();
			pendingTransactionsByAddress.clear();

			printf("Error processing live transactions: %s!\n", e.what());
		}
	}
}
void bad_emplace_back_deque1(std::deque<int> &D, int n) {
  auto i0 = D.cbegin(), i1 = D.cend();
  D.emplace_back(n);
  *i0; // expected-warning{{Invalidated iterator accessed}}
  --i1; // expected-warning{{Invalidated iterator accessed}}
}
Esempio n. 27
0
 void emplace(Arguments&& ... args) {
     std::unique_lock<std::mutex> lock(mutex_);
     queue_.emplace_back(std::forward<Arguments>(args) ...);
 }
Esempio n. 28
0
 future<bool> add_listener() {
     return lock(),  listeners.emplace_back(), listeners.back().get_future();
 }
Esempio n. 29
0
 void AddTask(std::function<void()> workFn, std::function<void()> completionFn)
 {
     unique_lock lock(_mutex);
     _pending.emplace_back(workFn, completionFn);
     _condPending.notify_one();
 }
Esempio n. 30
0
 void emplace(Arguments&& ... args) {
     std::unique_lock<std::mutex> lock(mutex_);
     queue_.emplace_back(args ...);
 }