//-------------------------------------------------------------------------------------
void Bots::handleGameTick()
{
// time_t t = ::time(NULL);
// DEBUG_MSG("EntityApp::handleGameTick[%"PRTime"]:%u\n", t, time_);
ClientApp::handleGameTick();
pEventPoller_->processPendingEvents(0.0);
{
AUTO_SCOPED_PROFILE("updateBots");
CLIENTS::iterator iter = clients().begin();
for(;iter != clients().end();)
{
Network::Channel* pChannel = iter->first;
ClientObject* pClientObject = iter->second;
++iter;
if(pClientObject->isDestroyed())
{
delClient(pChannel);
continue;
}
pClientObject->gameTick();
}
}
}
void CSSCanvasValue::canvasChanged(HTMLCanvasElement*, const FloatRect& changedRect)
{
IntRect imageChangeRect = enclosingIntRect(changedRect);
RenderObjectSizeCountMap::const_iterator end = clients().end();
for (RenderObjectSizeCountMap::const_iterator curr = clients().begin(); curr != end; ++curr)
const_cast<RenderObject*>(curr->key)->imageChanged(static_cast<WrappedImagePtr>(this), &imageChangeRect);
}
void CSSCrossfadeValue::crossfadeChanged(const IntRect&)
{
RenderObjectSizeCountMap::const_iterator end = clients().end();
for (RenderObjectSizeCountMap::const_iterator curr = clients().begin(); curr != end; ++curr) {
RenderObject* client = const_cast<RenderObject*>(curr->key);
client->imageChanged(static_cast<WrappedImagePtr>(this));
}
}
void CSSFilterImageValue::filterImageChanged(const IntRect&)
{
HashCountedSet<RenderObject*>::const_iterator end = clients().end();
for (HashCountedSet<RenderObject*>::const_iterator curr = clients().begin(); curr != end; ++curr) {
RenderObject* client = const_cast<RenderObject*>(curr->key);
client->imageChanged(static_cast<WrappedImagePtr>(this));
}
}
//-------------------------------------------------------------------------------------
void Bots::handleGameTick()
{
// time_t t = ::time(NULL);
// DEBUG_MSG("EntityApp::handleGameTick[%"PRTime"]:%u\n", t, time_);
ClientApp::handleGameTick();
pEventPoller_->processPendingEvents(0.0);
CLIENTS::iterator iter = clients().begin();
for(;iter != clients().end(); iter++)
iter->second.get()->gameTick();
}
inline void CSSCrossfadeValue::crossfadeChanged()
{
if (!m_subimagesAreReady)
return;
for (auto& client : clients())
client.key->imageChanged(this);
}
int main ()
{
// One I/O thread in the thread pool will do.
zmq::context_t ctx (1);
// Create an endpoint for worker threads to connect to.
// We are using XREQ socket so that processing of one request
// won't block other requests.
zmq::socket_t workers (ctx, ZMQ_XREQ);
workers.bind ("inproc://workers");
// Create an endpoint for client applications to connect to.
// We are usign XREP socket so that processing of one request
// won't block other requests.
zmq::socket_t clients (ctx, ZMQ_XREP);
clients.bind ("tcp://lo:5555");
// We'll use 11 application threads. Main thread will be used to run
// 'dispatcher' (queue). Aside of that there'll be 10 worker threads.
// Launch 10 worker threads.
for (int i = 0; i != 10; i++) {
pthread_t worker;
int rc = pthread_create (&worker, NULL, worker_routine, (void*) &ctx);
assert (rc == 0);
}
// Use queue device as a dispatcher of messages from clients to worker
// threads.
zmq::device (ZMQ_QUEUE, clients, workers);
return 0;
}
void RDMAServerSocket::accept(client_t client_id) const {
ibv_qp_init_attr qp_attr = {};
qp_attr.qp_type = IBV_QPT_RC;
qp_attr.cap.max_send_wr = 256;
qp_attr.cap.max_recv_wr = 0;
qp_attr.cap.max_send_sge = 1;
qp_attr.cap.max_recv_sge = 0;
qp_attr.cap.max_inline_data = 72;
qp_attr.recv_cq = cq;
qp_attr.send_cq = cq;
qp_attr.srq = id->srq;
qp_attr.sq_sig_all = 1;
check_zero(rdma_create_qp(client_id.get(), NULL, &qp_attr));
check_zero(rdma_accept(client_id.get(), nullptr));
clients([client_id = std::move(client_id)](auto && clients) mutable {
auto pos = std::lower_bound(std::begin(clients), std::end(clients),
client_id->qp->qp_num,
[](const auto &client, const qp_t &qp_num) {
return client->qp->qp_num < qp_num;
});
clients.insert(pos, std::move(client_id));
});
}
void RenderSVGResourceContainer::registerResource()
{
SVGDocumentExtensions* extensions = svgExtensionsFromNode(node());
if (!extensions->hasPendingResource(m_id)) {
extensions->addResource(m_id, this);
return;
}
OwnPtr<SVGDocumentExtensions::SVGPendingElements> clients(extensions->removePendingResource(m_id));
// Cache us with the new id.
extensions->addResource(m_id, this);
// Update cached resources of pending clients.
const SVGDocumentExtensions::SVGPendingElements::const_iterator end = clients->end();
for (SVGDocumentExtensions::SVGPendingElements::const_iterator it = clients->begin(); it != end; ++it) {
ASSERT((*it)->hasPendingResources());
extensions->clearHasPendingResourcesIfPossible(*it);
RenderObject* renderer = (*it)->renderer();
if (!renderer)
continue;
SVGResourcesCache::clientStyleChanged(renderer, StyleDifferenceLayout, renderer->style());
renderer->setNeedsLayout(true);
}
}
int main(int argc, char *argv[])
{
if (!init(argc, argv))
exit(0);
std::cout << "Starting prime server with " << g_conf_threads << " worker thread(s)" << std::endl;
std::cout << "Listening on port " << g_conf_port << std::endl;
// Prepare ZMQ context and sockets
zmq::context_t context(1);
zmq::socket_t clients (context, ZMQ_ROUTER);
char bind_str[20];
sprintf(bind_str, "tcp://*:%d", g_conf_port);
clients.bind (bind_str);
zmq::socket_t workers (context, ZMQ_DEALER);
workers.bind ("inproc://workers");
// Launch pool of worker threads
for (uint8_t thread_nbr = 0; thread_nbr != g_conf_threads; thread_nbr++)
{
pthread_t worker;
pthread_create(&worker, NULL, worker_thread, (void *) &context);
}
// Connect work threads to client threads via a queue
zmq::proxy(static_cast<void *>(clients), static_cast<void *>(workers), NULL);
return 0;
}
void CSSCrossfadeValue::crossfadeChanged(const IntRect&)
{
for (const auto& curr : clients()) {
LayoutObject* client = const_cast<LayoutObject*>(curr.key);
client->imageChanged(static_cast<WrappedImagePtr>(this));
}
}
bool CSSCrossfadeValue::willRenderImage() const {
for (const auto& curr : clients()) {
if (const_cast<LayoutObject*>(curr.key)->willRenderImage())
return true;
}
return false;
}
PassRefPtr<Image> CSSCanvasValue::image(RenderObject* renderer, const IntSize& /*size*/)
{
ASSERT(clients().contains(renderer));
HTMLCanvasElement* elt = element(renderer->document());
if (!elt || !elt->buffer())
return 0;
return elt->copiedImage();
}
void CSSStyleSheetResource::appendData(const char* data, size_t length) {
Resource::appendData(data, length);
if (m_didNotifyFirstData)
return;
ResourceClientWalker<StyleSheetResourceClient> w(clients());
while (StyleSheetResourceClient* c = w.next())
c->didAppendFirstData(this);
m_didNotifyFirstData = true;
}
void FontResource::fontLoadLongLimitCallback(TimerBase*) {
if (!isLoading())
return;
DCHECK_EQ(m_loadLimitState, ShortLimitExceeded);
m_loadLimitState = LongLimitExceeded;
ResourceClientWalker<FontResourceClient> walker(clients());
while (FontResourceClient* client = walker.next())
client->fontLoadLongLimitExceeded(this);
}
void SVGUseElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGStyledTransformableElement::svgAttributeChanged(attrName);
bool isXYAttribute = attrName == SVGNames::xAttr || attrName == SVGNames::yAttr;
bool isWidthHeightAttribute = attrName == SVGNames::widthAttr || attrName == SVGNames::heightAttr;
if (isXYAttribute || isWidthHeightAttribute)
updateRelativeLengthsInformation();
if (SVGTests::handleAttributeChange(this, attrName))
return;
RenderObject* object = renderer();
if (!object)
return;
if (SVGURIReference::isKnownAttribute(attrName)) {
if (hasPendingResources()) {
OwnPtr<SVGDocumentExtensions::SVGPendingElements> clients(document()->accessSVGExtensions()->removePendingResource(m_resourceId));
ASSERT(!clients->isEmpty());
const SVGDocumentExtensions::SVGPendingElements::const_iterator end = clients->end();
for (SVGDocumentExtensions::SVGPendingElements::const_iterator it = clients->begin(); it != end; ++it) {
ASSERT((*it)->hasPendingResources());
(*it)->setHasPendingResources(false);
}
m_resourceId = String();
setHasPendingResources(false);
}
invalidateShadowTree();
return;
}
if (isXYAttribute) {
updateContainerOffsets();
return;
}
if (isWidthHeightAttribute) {
updateContainerSizes();
return;
}
// Be very careful here, if svgAttributeChanged() has been called because a SVG CSS property changed, we do NOT want to reclone the tree!
if (SVGStyledElement::isKnownAttribute(attrName)) {
setNeedsStyleRecalc();
return;
}
if (SVGLangSpace::isKnownAttribute(attrName)
|| SVGExternalResourcesRequired::isKnownAttribute(attrName))
invalidateShadowTree();
}
// Client finder by id.
qjackctlAlsaClient *qjackctlAlsaClientList::findClient ( int iAlsaClient )
{
QListIterator<qjackctlClientItem *> iter(clients());
while (iter.hasNext()) {
qjackctlAlsaClient *pClient
= static_cast<qjackctlAlsaClient *> (iter.next());
if (iAlsaClient == pClient->alsaClient())
return pClient;
}
return NULL;
}
/*!
* Disconnects all clients, or disconnects from the server.
*/
void QxtRPCService::disconnectAll()
{
if(isClient())
disconnectServer();
if(isServer()) {
QList<quint64> clientIDs = clients();
foreach(quint64 id, clientIDs) {
// Disconnect from each client in turn.
disconnectClient(id);
}
}
int main ()
{
// Prepare our context and sockets
zmq::context_t context (1);
zmq::socket_t servers (context, ZMQ_DEALER);
servers.bind ("tcp://*:5555");
zmq::socket_t clients (context, ZMQ_ROUTER);
clients.bind ("tcp://*:5556");
zmq_device (ZMQ_FORWARDER, (void *)clients, (void *)servers);
return 0;
}
int main ()
{
// Prepare our context and sockets
zmq::context_t context (1);
zmq::socket_t clients (context, ZMQ_ROUTER);
clients.bind ("tcp://*:5555");
zmq::socket_t workers (context, ZMQ_DEALER);
workers.bind ("inproc://workers");
// Launch pool of worker threads
for (int thread_nbr = 0; thread_nbr != 5; thread_nbr++) {
pthread_t worker;
pthread_create (&worker, NULL, worker_routine, (void *) &context);
}
// Connect work threads to client threads via a queue
zmq::device (ZMQ_QUEUE, clients, workers);
return 0;
}
void SurfaceComposerClient::closeGlobalTransaction()
{
gLock.lock();
SortedVector< sp<SurfaceComposerClient> > clients(gOpenTransactions);
gOpenTransactions.clear();
gLock.unlock();
const size_t N = clients.size();
VERBOSE("closeGlobalTransaction (%ld clients)", N);
sp<ISurfaceComposer> sm(getComposerService());
sm->openGlobalTransaction();
for (size_t i=0; i<N; i++) {
clients[i]->closeTransaction();
}
sm->closeGlobalTransaction();
}
int emit()
{
std::string sig(cmd + EMIT_LEN);
if (signals.count(sig) == 0)
{
return sig.length();
}
if (subs.count(sig) == 0)
{
std::cerr << "This should not have happened" << std::endl;
exit(2);
}
for (auto it = subs.at(sig).begin(); it != subs.at(sig).end(); ++it)
{
clients().at(*it).to_emit.push(sig);
}
return sig.length();
}
void CSSStyleSheetResource::checkNotify() {
// Decode the data to find out the encoding and cache the decoded sheet text.
if (data())
setDecodedSheetText(decodedText());
ResourceClientWalker<StyleSheetResourceClient> w(clients());
while (StyleSheetResourceClient* c = w.next()) {
markClientFinished(c);
c->setCSSStyleSheet(resourceRequest().url(), response().url(), encoding(),
this);
}
// Clear raw bytes as now we have the full decoded sheet text.
// We wait for all LinkStyle::setCSSStyleSheet to run (at least once)
// as SubresourceIntegrity checks require raw bytes.
// Note that LinkStyle::setCSSStyleSheet can be called from didAddClient too,
// but is safe as we should have a cached ResourceIntegrityDisposition.
clearData();
}
int Comp2::c2method( int input){
// Prepare our context and sockets
zmq::context_t context (1);
zmq::socket_t clients (context, ZMQ_ROUTER);
clients.bind ("tcp://0.0.0.0:8123");
zmq::socket_t workers (context, ZMQ_DEALER);
workers.bind ("inproc://workers");
// Launch pool of worker threads
for (int thread_nbr = 0; thread_nbr != 10; thread_nbr++) {
pthread_t worker;
pthread_create (&worker, NULL, worker_routine, (void *) &context);
}
// Connect work threads to client threads via a queue
zmq::proxy ((void *)clients, (void *)workers, NULL);
return input * 4;
}
void LayoutSVGResourceContainer::registerResource()
{
SVGDocumentExtensions& extensions = svgExtensionsFromElement(element());
if (!extensions.hasPendingResource(m_id)) {
extensions.addResource(m_id, this);
return;
}
SVGDocumentExtensions::SVGPendingElements* clients(extensions.removePendingResource(m_id));
// Cache us with the new id.
extensions.addResource(m_id, this);
// Update cached resources of pending clients.
for (const auto& pendingClient : *clients) {
ASSERT(pendingClient->hasPendingResources());
extensions.clearHasPendingResourcesIfPossible(pendingClient);
LayoutObject* layoutObject = pendingClient->layoutObject();
if (!layoutObject)
continue;
const ComputedStyle& style = layoutObject->styleRef();
// If the client has a layer (is a non-SVGElement) we need to signal
// invalidation in the same way as is done in markAllResourceClientsForInvalidation above.
if (layoutObject->hasLayer() && resourceType() == FilterResourceType) {
if (style.hasFilter())
toLayoutBoxModelObject(layoutObject)->layer()->filterNeedsPaintInvalidation();
// If this is the SVG root, we could have both 'filter' and
// '-webkit-filter' applied, so we need to do the invalidation
// below as well, unless we can optimistically determine that
// 'filter' does not apply to the element in question.
if (!layoutObject->isSVGRoot() || !style.svgStyle().hasFilter())
continue;
}
StyleDifference diff;
diff.setNeedsFullLayout();
SVGResourcesCache::clientStyleChanged(layoutObject, diff, style);
layoutObject->setNeedsLayoutAndFullPaintInvalidation(LayoutInvalidationReason::SvgResourceInvalidated);
}
}
int main( int argc, char **argv ){
zmq::context_t ctx(2);
zmq::socket_t workers( ctx, ZMQ_XREQ );
workers.bind( "inproc://workers" );
zmq::socket_t clients( ctx, ZMQ_XREP );
clients.bind( "tcp://*:5555" );
std::cout << "Starting worker threads..." << std::endl;
for( size_t i = 0 ; i < 10 ; ++i ){
pthread_t worker;
int rc = pthread_create( &worker, NULL, suisto_worker, (void*)&ctx );
}
std::cout << "Starting queue..." << std::endl << std::endl;
zmq::device( ZMQ_QUEUE, clients, workers );
return 0;
}
void add_connection()
{
int conn_sock = accept(listen_sock, NULL, NULL);
std::cerr << "accept " << conn_sock << std::endl;
if (conn_sock < 0)
{
perror(ERROR"accept");
return;
}
clients().emplace(conn_sock, client_t(conn_sock));
int curr = 1;
while (curr < MAX_SOCKETS && !free_position[curr])
{
++curr;
}
if (curr < MAX_SOCKETS)
{
sockets[curr].fd = conn_sock;
sockets[curr].events = POLLERR | POLLIN | POLLOUT;
sockets[curr].revents = 0;
free_position[curr] = false;
++count_sockets;
}
}
void ScriptResource::appendData(const char* data, size_t length) {
Resource::appendData(data, length);
ResourceClientWalker<ScriptResourceClient> walker(clients());
while (ScriptResourceClient* client = walker.next())
client->notifyAppendData(this);
}
void CSSCanvasValue::canvasResized(HTMLCanvasElement*)
{
for (auto it = clients().begin(), end = clients().end(); it != end; ++it)
it->key->imageChanged(static_cast<WrappedImagePtr>(this));
}
void CSSCanvasValue::canvasResized(HTMLCanvasElement*)
{
RenderObjectSizeCountMap::const_iterator end = clients().end();
for (RenderObjectSizeCountMap::const_iterator curr = clients().begin(); curr != end; ++curr)
const_cast<RenderObject*>(curr->key)->imageChanged(static_cast<WrappedImagePtr>(this));
}
