void manageMenu(Client *clients, Worker *workers, Order *orders, Product *products, int *clientCount, int *workerCount, int *orderCount, int *productCount) { int op, posLogged = 0; do { manageMenuPrint(); readInt(&op, MENU_OPT_MIN, MENU_OPT_MAX, MENU_MSG_OPT); switch (op) { case 0: //exit break; case 1: //Register Worker cleanScreen(); addWorker(workers, workerCount); printf("\n\n"); break; case 2: //Login Worker cleanScreen(); posLogged = loginWorker(workers, workerCount); if (posLogged != EOF) { if (workers[posLogged].type == 1) { workerHandlingMenu(clients, workers, orders, products, clientCount, workerCount, orderCount, productCount, posLogged); } else { workerDeliveryMenu(clients, workers, orders, clientCount, workerCount, orderCount, posLogged); } } break; default: printf(MENU_MSG_OPT_INVALID); } } while (op != 0); }
bool WorkerPool::init() { bool ret = false; char buffername[128] = {0}; //to Create two IOCP? one is secdule thread and other is worker thread; //原子队列? if ((io_handler_ = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0 , TEST_THREAD_COUNT )) != NULL) { //Create Thread //Create single thread //create iocp,bind iocp //create 10 thread //bind thread to iocp std::function<void(void)> f = std::bind(&WorkerPool::dispatch, this); for (unsigned int i = 0; i < max_threads; ++i) { buffername[0] = 0; sprintf(buffername, "test thread%d", i); WorkerImpl* work_thread = new Win32ThreadImpl(f, buffername); addWorker(work_thread); } } return ret; }
void FastCgiInterface::acceptNewConnection() { /* We're connected, setup a FastCgiSocketManager. * This will delete itself when appropriate (via deleteLater()) */ FastCgiSocketManager* socket = new FastCgiSocketManager(m_socketServer->nextPendingConnection(), 0); addWorker(socket); }
void TaskScheduler::waitUntilComplete(const Task* task) { if(task->isCanceled()) return; { Lock lock(mCompleteMutex); while(!task->isComplete()) { addWorker(); mTaskCompleteCond.wait(lock); removeWorker(); } } }
/* * Start a worker thread. This is called by eval() and load(). Not by preload() or by Worker() * It always joins. */ static EjsVar *startWorker(Ejs *ejs, EjsWorker *worker, int timeout) { Ejs *inside; EjsVar *result; mprAssert(ejs); mprAssert(worker); mprAssert(worker->state == EJS_WORKER_BEGIN); if (worker->state > EJS_WORKER_BEGIN) { ejsThrowStateError(ejs, "Worker has already started"); return 0; } mprAssert(worker->pair->state == EJS_WORKER_BEGIN); addWorker(ejs, worker); worker->state = EJS_WORKER_STARTED; worker->obj.var.permanent = 1; if (mprStartWorker(ejs, (MprWorkerProc) workerMain, (void*) worker, MPR_NORMAL_PRIORITY) < 0) { ejsThrowStateError(ejs, "Can't start worker"); worker->obj.var.permanent = 0; return 0; } if (timeout == 0) { return ejs->undefinedValue; } if (timeout < 0) { timeout = MAXINT; } if (join(ejs, (EjsVar*) worker, timeout) < 0) { ejsThrowStateError(ejs, "Timeout (%d)", timeout); return ejs->undefinedValue; } mprAssert(worker->pair); mprAssert(worker->pair->ejs); inside = worker->pair->ejs; result = ejsSerialize(ejs, inside->result, -1, 0, 0); if (result == 0) { return ejs->nullValue; } return ejsDeserialize(ejs, (EjsString*) result); }
void PipelineManager::addWorkerEvent(Jzon::Node* params, Jzon::Object &outputNode) { int id; std::string type; Worker* worker = NULL; if(!params) { outputNode.Add("error", "Error creating worker. Invalid JSON format..."); return; } if (!params->Has("id") || !params->Has("type")) { outputNode.Add("error", "Error creating worker. Invalid JSON format..."); return; } id = params->Get("id").ToInt(); type = params->Get("type").ToString(); if (type.compare("livemedia") == 0){ worker = new LiveMediaWorker(); } else { worker = new Worker(); } if (!worker) { outputNode.Add("error", "Error creating worker. Check type..."); return; } if (!addWorker(id, worker)) { outputNode.Add("error", "Error adding worker to filter. Check filter ID..."); return; } outputNode.Add("error", Jzon::null); }
static EjsWorker *initWorker(Ejs *ejs, EjsWorker *worker, Ejs *baseVM, cchar *name, EjsArray *search, cchar *scriptFile) { Ejs *wejs; EjsWorker *self; EjsName sname; static int workerSeqno = 0; ejsBlockGC(ejs); if (worker == 0) { worker = ejsCreateWorker(ejs); } worker->ejs = ejs; worker->state = EJS_WORKER_BEGIN; if (name) { worker->name = sclone(name); } else { lock(ejs); worker->name = sfmt("worker-%d", workerSeqno++); unlock(ejs); } /* Create a new interpreter and an "inside" worker object and pair it with the current "outside" worker. The worker interpreter gets a new dispatcher */ if (baseVM) { if ((wejs = ejsCloneVM(baseVM)) == 0) { ejsThrowMemoryError(ejs); return 0; } } else { if ((wejs = ejsCreateVM(0, 0, ejs->flags)) == 0) { ejsThrowMemoryError(ejs); return 0; } if (ejsLoadModules(wejs, 0, 0) < 0) { return 0; } } worker->pair = self = ejsCreateWorker(wejs); self->state = EJS_WORKER_BEGIN; self->ejs = wejs; self->inside = 1; self->pair = worker; self->name = sjoin("inside-", worker->name, NULL); #if MOB mprEnableDispatcher(wejs->dispatcher); #endif if (search) { ejsSetSearchPath(ejs, (EjsArray*) search); } // TODO - these should be don't delete ejsSetProperty(ejs, worker, ES_Worker_name, ejsCreateStringFromAsc(ejs, self->name)); ejsSetProperty(wejs, self, ES_Worker_name, ejsCreateStringFromAsc(wejs, self->name)); sname = ejsName(wejs, EJS_WORKER_NAMESPACE, "self"); ejsSetPropertyByName(wejs, wejs->global, sname, self); /* Workers have a dedicated namespace to enable viewing of the worker globals (self, onmessage, postMessage...) */ ejsDefineReservedNamespace(wejs, wejs->global, NULL, EJS_WORKER_NAMESPACE); addWorker(ejs, worker); if (scriptFile) { worker->scriptFile = sclone(scriptFile); worker->state = EJS_WORKER_STARTED; if (mprCreateEvent(wejs->dispatcher, "workerMain", 0, (MprEventProc) workerMain, self, 0) < 0) { mprRemoveItem(ejs->workers, worker); ejsThrowStateError(ejs, "Cannot create worker event"); return 0; } } return worker; }
void ThriftServer::setup() { DCHECK_NOTNULL(cpp2Pfac_.get()); DCHECK_GT(nWorkers_, 0); uint32_t threadsStarted = 0; bool eventBaseAttached = false; // Make sure EBM exists if we haven't set one explicitly getEventBaseManager(); // Initialize event base for this thread, ensure event_init() is called serveEventBase_ = eventBaseManager_->getEventBase(); // Print some libevent stats LOG(INFO) << "libevent " << TEventBase::getLibeventVersion() << " method " << TEventBase::getLibeventMethod(); try { // We check for write success so we don't need or want SIGPIPEs. signal(SIGPIPE, SIG_IGN); if (!observer_ && apache::thrift::observerFactory_) { observer_ = apache::thrift::observerFactory_->getObserver(); } // bind to the socket if (socket_ == nullptr) { socket_.reset(new TAsyncServerSocket()); socket_->setShutdownSocketSet(shutdownSocketSet_.get()); if (port_ != -1) { socket_->bind(port_); } else { DCHECK(address_.isInitialized()); socket_->bind(address_); } } socket_->listen(listenBacklog_); socket_->setMaxNumMessagesInQueue(maxNumMsgsInQueue_); socket_->setAcceptRateAdjustSpeed(acceptRateAdjustSpeed_); // We always need a threadmanager for cpp2. if (!threadFactory_) { setThreadFactory(std::shared_ptr<ThreadFactory>( new PosixThreadFactory)); } if (!threadManager_) { std::shared_ptr<apache::thrift::concurrency::ThreadManager> threadManager(PriorityThreadManager::newPriorityThreadManager( nPoolThreads_ > 0 ? nPoolThreads_ : nWorkers_, true /*stats*/)); threadManager->enableCodel(getEnableCodel()); threadManager->start(); setThreadManager(threadManager); } threadManager_->setExpireCallback([&](std::shared_ptr<Runnable> r) { EventTask* task = dynamic_cast<EventTask*>(r.get()); if (task) { task->expired(); } }); threadManager_->setCodelCallback([&](std::shared_ptr<Runnable> r) { auto observer = getObserver(); if (observer) { observer->queueTimeout(); } }); auto b = std::make_shared<boost::barrier>(nWorkers_ + 1); // Create the worker threads. workers_.reserve(nWorkers_); for (uint32_t n = 0; n < nWorkers_; ++n) { addWorker(); workers_[n].worker->getEventBase()->runInLoop([b](){ b->wait(); }); } // Update address_ with the address that we are actually bound to. // (This is needed if we were supplied a pre-bound socket, or if address_'s // port was set to 0, so an ephemeral port was chosen by the kernel.) socket_->getAddress(&address_); // Notify handler of the preServe event if (eventHandler_ != nullptr) { eventHandler_->preServe(&address_); } for (auto& worker: workers_) { worker.thread->start(); ++threadsStarted; worker.thread->setName(folly::to<std::string>("Cpp2Worker", threadsStarted)); } // Wait for all workers to start b->wait(); socket_->attachEventBase(eventBaseManager_->getEventBase()); eventBaseAttached = true; socket_->startAccepting(); } catch (...) { // XXX: Cpp2Worker::acceptStopped() calls // eventBase_.terminateLoopSoon(). Normally this stops the // worker from processing more work and stops the event loop. // However, if startConsuming() and eventBase_.loop() haven't // run yet this won't do the right thing. The worker thread // will still continue to call startConsuming() later, and // will then start the event loop. for (uint32_t i = 0; i < threadsStarted; ++i) { workers_[i].worker->acceptStopped(); workers_[i].thread->join(); } workers_.clear(); if (socket_) { if (eventBaseAttached) { socket_->detachEventBase(); } socket_.reset(); } throw; } }
/* * function Worker(script: String = null, options: Object = null) * * Script is optional. If supplied, the script is run immediately by a worker thread. This call * does not block. Options are: search and name. */ static EjsVar *workerConstructor(Ejs *ejs, EjsWorker *worker, int argc, EjsVar **argv) { Ejs *wejs; EjsVar *options, *value; EjsName qname; EjsWorker *self; cchar *search, *name; worker->ejs = ejs; worker->state = EJS_WORKER_BEGIN; options = (argc == 2) ? (EjsVar*) argv[1]: NULL; name = 0; search = ejs->ejsPath; if (options) { value = ejsGetPropertyByName(ejs, options, ejsName(&qname, "", "search")); if (ejsIsString(value)) { search = ejsGetString(value); } value = ejsGetPropertyByName(ejs, options, ejsName(&qname, "", "name")); if (ejsIsString(value)) { name = ejsGetString(value); } } if (name) { worker->name = mprStrdup(worker, name); } else { worker->name = mprAsprintf(worker, -1, "worker-%d", mprGetListCount(ejs->workers)); } /* * Create a new interpreter and an "inside" worker object and pair it with the current "outside" worker. */ wejs = ejsCreate(ejs->service, NULL, search, 0); if (wejs == 0) { ejsThrowMemoryError(ejs); return 0; } worker->pair = self = ejsCreateWorker(wejs); self->state = EJS_WORKER_BEGIN; self->ejs = wejs; self->inside = 1; self->pair = worker; self->name = mprStrcat(self, -1, "inside-", worker->name, NULL); ejsSetProperty(ejs, (EjsVar*) worker, ES_ejs_sys_Worker_name, (EjsVar*) ejsCreateString(ejs, self->name)); ejsSetProperty(wejs, (EjsVar*) self, ES_ejs_sys_Worker_name, (EjsVar*) ejsCreateString(wejs, self->name)); ejsSetProperty(wejs, wejs->global, ES_ejs_sys_worker_self, (EjsVar*) self); /* * Workers have a dedicated namespace to enable viewing of the worker globals (self, onmessage, postMessage...) */ ejsDefineReservedNamespace(wejs, wejs->globalBlock, 0, EJS_WORKER_NAMESPACE); /* * Make the inside worker permanent so we don't need to worry about whether worker->pair->ejs is valid */ self->obj.var.permanent = 1; if (argc > 0 && ejsIsPath(argv[0])) { addWorker(ejs, worker); worker->scriptFile = mprStrdup(worker, ((EjsPath*) argv[0])->path); worker->state = EJS_WORKER_STARTED; worker->obj.var.permanent = 1; if (mprStartWorker(ejs, (MprWorkerProc) workerMain, (void*) worker, MPR_NORMAL_PRIORITY) < 0) { ejsThrowStateError(ejs, "Can't start worker"); worker->obj.var.permanent = 0; return 0; } } return (EjsVar*) worker; }
void ThriftServer::setup() { DCHECK_NOTNULL(cpp2Pfac_.get()); DCHECK_GT(nWorkers_, 0); uint32_t threadsStarted = 0; bool eventBaseAttached = false; // Make sure EBM exists if we haven't set one explicitly getEventBaseManager(); // Initialize event base for this thread, ensure event_init() is called serveEventBase_ = eventBaseManager_->getEventBase(); // Print some libevent stats LOG(INFO) << "libevent " << TEventBase::getLibeventVersion() << " method " << TEventBase::getLibeventMethod(); try { // We check for write success so we don't need or want SIGPIPEs. signal(SIGPIPE, SIG_IGN); if (!observer_ && apache::thrift::observerFactory_) { observer_ = apache::thrift::observerFactory_->getObserver(); } // bind to the socket if (!serverChannel_) { if (socket_ == nullptr) { socket_.reset(new TAsyncServerSocket()); socket_->setShutdownSocketSet(shutdownSocketSet_.get()); if (port_ != -1) { socket_->bind(port_); } else { DCHECK(address_.isInitialized()); socket_->bind(address_); } } socket_->listen(listenBacklog_); socket_->setMaxNumMessagesInQueue(maxNumMsgsInQueue_); socket_->setAcceptRateAdjustSpeed(acceptRateAdjustSpeed_); } // We always need a threadmanager for cpp2. if (!threadFactory_) { setThreadFactory( std::make_shared<apache::thrift::concurrency::NumaThreadFactory>()); } if (FLAGS_sasl_policy == "required" || FLAGS_sasl_policy == "permitted") { if (!saslThreadManager_) { saslThreadManager_ = ThreadManager::newSimpleThreadManager( nPoolThreads_ > 0 ? nPoolThreads_ : nWorkers_, /* count */ 0, /* pendingTaskCountMax -- no limit */ false, /* enableTaskStats */ 0 /* maxQueueLen -- large default */); saslThreadManager_->setNamePrefix("thrift-sasl"); saslThreadManager_->threadFactory(threadFactory_); saslThreadManager_->start(); } auto saslThreadManager = saslThreadManager_; if (getSaslServerFactory()) { // If the factory is already set, don't override it with the default } else if (FLAGS_kerberos_service_name.empty()) { // If the service name is not specified, not need to pin the principal. // Allow the server to accept anything in the keytab. setSaslServerFactory([=] (TEventBase* evb) { return std::unique_ptr<SaslServer>( new GssSaslServer(evb, saslThreadManager)); }); } else { char hostname[256]; if (gethostname(hostname, 255)) { LOG(FATAL) << "Failed getting hostname"; } setSaslServerFactory([=] (TEventBase* evb) { auto saslServer = std::unique_ptr<SaslServer>( new GssSaslServer(evb, saslThreadManager)); saslServer->setServiceIdentity( FLAGS_kerberos_service_name + "/" + hostname); return std::move(saslServer); }); } } if (!threadManager_) { std::shared_ptr<apache::thrift::concurrency::ThreadManager> threadManager(new apache::thrift::concurrency::NumaThreadManager( nPoolThreads_ > 0 ? nPoolThreads_ : nWorkers_, true /*stats*/, getMaxRequests() /*maxQueueLen*/)); threadManager->enableCodel(getEnableCodel()); if (!poolThreadName_.empty()) { threadManager->setNamePrefix(poolThreadName_); } threadManager->start(); setThreadManager(threadManager); } threadManager_->setExpireCallback([&](std::shared_ptr<Runnable> r) { EventTask* task = dynamic_cast<EventTask*>(r.get()); if (task) { task->expired(); } }); threadManager_->setCodelCallback([&](std::shared_ptr<Runnable> r) { auto observer = getObserver(); if (observer) { observer->queueTimeout(); } }); if (!serverChannel_) { // regular server auto b = std::make_shared<boost::barrier>(nWorkers_ + 1); // Create the worker threads. workers_.reserve(nWorkers_); for (uint32_t n = 0; n < nWorkers_; ++n) { addWorker(); workers_[n].worker->getEventBase()->runInLoop([b](){ b->wait(); }); } // Update address_ with the address that we are actually bound to. // (This is needed if we were supplied a pre-bound socket, or if // address_'s port was set to 0, so an ephemeral port was chosen by // the kernel.) if (socket_) { socket_->getAddress(&address_); } // Notify handler of the preServe event if (eventHandler_ != nullptr) { eventHandler_->preServe(&address_); } for (auto& worker: workers_) { worker.thread->start(); ++threadsStarted; worker.thread->setName(folly::to<std::string>(cpp2WorkerThreadName_, threadsStarted)); } // Wait for all workers to start b->wait(); if (socket_) { socket_->attachEventBase(eventBaseManager_->getEventBase()); } eventBaseAttached = true; if (socket_) { socket_->startAccepting(); } } else { // duplex server // Create the Cpp2Worker DCHECK(workers_.empty()); WorkerInfo info; uint32_t workerID = 0; info.worker.reset(new Cpp2Worker(this, workerID, serverChannel_)); // no thread, use current one (shared with client) info.thread = nullptr; workers_.push_back(info); } } catch (...) { // XXX: Cpp2Worker::acceptStopped() calls // eventBase_.terminateLoopSoon(). Normally this stops the // worker from processing more work and stops the event loop. // However, if startConsuming() and eventBase_.loop() haven't // run yet this won't do the right thing. The worker thread // will still continue to call startConsuming() later, and // will then start the event loop. if (!serverChannel_) { for (uint32_t i = 0; i < threadsStarted; ++i) { workers_[i].worker->acceptStopped(); workers_[i].thread->join(); } } workers_.clear(); if (socket_) { if (eventBaseAttached) { socket_->detachEventBase(); } socket_.reset(); } // avoid crash on stop() serveEventBase_ = nullptr; throw; } }