示例#1
0
void LoadBalancer::new_worker(size_t i) {
    if (worker_proc[i]) {
        delete worker_proc[i];
        worker_proc[i] = nullptr;
    }

    if (isFinished())
        return;

    std::string logfilename = my_config.value("workerlog");
    if (logfilename.empty()) {
        worker_proc[i] = createWorker(nullptr, no_channels,
                                      static_cast<unsigned int>(i));
    } else {
        // In logfilename, replace all %d with worker number (i.e. i),
        // adjusting to fixed width by filling with zeroes.
        auto len = std::to_string(tot_no_workers).size();
        auto wno = std::to_string(i);
        wno = std::string(len-wno.size(), '0') + wno;
        while (true) {
            auto pos = logfilename.find("%d");
            if (pos == std::string::npos)
                break;
            logfilename.replace(pos, 2, wno);
        }
        worker_proc[i] = createWorker(logfilename, no_channels,
                                      static_cast<unsigned int>(i));
    }
    if (worker_proc[i])
        log() << "Created worker " << i << ", pid: " << worker_proc[i]->pid();
}
示例#2
0
void WatcherRunner::start() {
  // Set worker performance counters to an initial state.
  Watcher::resetWorkerCounters(0);

  // Enter the watch loop.
  do {
    if (use_worker_ && !watch(Watcher::getWorker())) {
      if (Watcher::fatesBound()) {
        // A signal has interrupted the watcher.
        break;
      }
      // The watcher failed, create a worker.
      createWorker();
    }

    // Loop over every managed extension and check sanity.
    std::vector<std::string> failing_extensions;
    for (const auto& extension : Watcher::extensions()) {
      if (!watch(*extension.second)) {
        if (!createExtension(extension.first)) {
          failing_extensions.push_back(extension.first);
        }
      }
    }
    // If any extension creations failed, stop managing them.
    for (const auto& failed_extension : failing_extensions) {
      Watcher::removeExtensionPath(failed_extension);
    }
    pauseMilli(getWorkerLimit(INTERVAL) * 1000);
  } while (!interrupted() && ok());
}
示例#3
0
	ClientController::ClientController()
		: mThread(new QThread())
	{
		mWorker = createWorker();

		mConnection = createConnection(mWorker);

		mThread->start();
	}
示例#4
0
Worker * createSingleWorker(){
    Worker * wp = NULL;
     
    wp = createWorker(1, NULL);
    if (wp == NULL){
        ntLogging(LOG_FATAL,"createSingleWorker failed");
        return NULL;
    }
    return wp;
}
示例#5
0
void ThreadPool::unsafeAddWorkers(std::size_t to_create, PolymorphicWorkerFactory factory, LockPtr lock)
{
    this->num_pseudo_workers += to_create;

    for (std::size_t i = 0; i < to_create; ++i)
        workers.insert(createWorker(factory));

    if (lock)
        lock->unlock();
}
示例#6
0
	//! Starts the workpool, creating _minwkrcnt
	void start(ushort _minwkrcnt = 0){
		Locker<Mutex> lock(mtx);
		if(state() == Running){
			return;
		}
		if(state() != Stopped){
			doStop(lock, true);
		}
		wkrcnt = 0;
		state(Running);
		for(ushort i(0); i < _minwkrcnt; ++i){
			createWorker();
		}
	}
示例#7
0
void CController::init()
{
	if(mDeviceCount > 0) {
		for(int i=0; i<mDeviceCount; ++i)
			createWorker(i);

		if(!mThreadCont.empty()) {
			SHARED_VECQTHREAD::const_iterator it = mThreadCont.begin();
			for(; it != mThreadCont.end(); ++it)
				it->get()->start(QThread::NormalPriority);
		}

		mWorkerCont.at(0)->resume();
	}
}
示例#8
0
void createWorkers(struct config* config) {

  config->workers = malloc(sizeof(struct worker*)*config->n_workers);
  int i;
  for( i = 0; i < config->n_workers; i++) {
    config->workers[i] = createWorker(config, i);
  }

  if(config->n_workers > config->n_connections_total ) {
    printf("Overridge n_connections_total because < n_workers\n");
    config->n_connections_total = config->n_workers;
  }

  int total_connections = 0;
  for(i = 0; i < config->n_workers; i++) {
    int num_worker_connections = config->n_connections_total/config->n_workers + (i < config->n_connections_total % config->n_workers);
    printf("num_worker_connections %d\n", num_worker_connections);
    total_connections += num_worker_connections;
    config->workers[i]->connections = malloc(sizeof(struct conn*) * num_worker_connections);
    config->workers[i]->nConnections = num_worker_connections;
    config->workers[i]->received_warmup_keys = 0;
    int j;
    int server=i % config->n_servers; 
    for(j = 0; j < num_worker_connections; j++) {
      config->workers[i]->connections[j] = createConnection(config->server_ip_address[server], config->server_port[server], config->protocol_mode, config->naggles);
    }
    int rc;
    //Create receive thread
    rc = pthread_create(&config->workers[i]->thread, NULL, workerFunction, config->workers[i]);
    if(rc) {
      printf("Error creating receive thread\n");
    }
  }
  printf("Created %d connections total\n", total_connections);


}//createWorkers()