C++ thread_group::create_thread方法代码示例

 TestingSetup() {
     fPrintToDebugger = true; // don't want to write to debug.log file
     noui_connect();
     bitdb.MakeMock();
     pathTemp = GetTempPath() / strprintf("test_servx_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
     boost::filesystem::create_directories(pathTemp);
     mapArgs["-datadir"] = pathTemp.string();
     pblocktree = new CBlockTreeDB(1 << 20, true);
     pcoinsdbview = new CCoinsViewDB(1 << 23, true);
     pcoinsTip = new CCoinsViewCache(*pcoinsdbview);
     InitBlockIndex();
     bool fFirstRun;
     pwalletMain = new CWallet("wallet.dat");
     pwalletMain->LoadWallet(fFirstRun);
     RegisterWallet(pwalletMain);
     nScriptCheckThreads = 3;
     for (int i=0; i < nScriptCheckThreads-1; i++)
         threadGroup.create_thread(&ThreadScriptCheck);
 }

void TaskManager::start()
{
    ThreadedList lst;
    for (int i = 0; i < 5; ++i) {
        TaskExecuter tex(i);
        tex.setList(&lst);
        m_threadGroup.create_thread(tex);
    }

    chrono::duration<uint32_t, milli> d(1000);
    for (int i = 0; i < 5; i++) {
        cout << "std called\n\r";
        this_thread::sleep_for(d);
    }

    for (auto str : lst.data()) {
        cout << str;
    }
}

int main()
{
    std::ifstream input(BINARY_DIR"/input.txt", std::ios::binary);
    SyncClass sc;
    for(int i = 0;i < THREADS_COUNT; i++)
        threads.create_thread(boost::bind(&SyncClass::writeMessage, &sc) );

    while(!input.eof()){
        Message msg(input);
        if(input.eof())
            break;
        boost::mutex::scoped_lock lock(queueMutex);
        msgQueue.push(msg);
    }
    sc.stopWorking();
    threads.join_all();

    return 0;
}

    TestingSetup() {
        fPrintToDebugLog = false; // don't want to write to debug.log file
        noui_connect();
#ifdef ENABLE_WALLET
        bitcoin_bitdb.MakeMock();
        bitcredit_bitdb.MakeMock();
        deposit_bitdb.MakeMock();
#endif
        pathTemp = GetTempPath() / strprintf("test_credits_%lu_%i", (unsigned long)GetTime(), (int)(GetRand(100000)));
        boost::filesystem::create_directories(pathTemp);
        mapArgs["-datadir"] = pathTemp.string();

        bitcredit_pblocktree = new Credits_CBlockTreeDB(1 << 20, true);
        bitcredit_pcoinsdbview = new Credits_CCoinsViewDB(1 << 23, true);
        credits_pcoinsTip = new Credits_CCoinsViewCache(*bitcredit_pcoinsdbview);

        bitcoin_pblocktree = new Bitcoin_CBlockTreeDB(1 << 20, true);
        bitcoin_pcoinsdbview = new Bitcoin_CCoinsViewDB(1 << 23, true);
        bitcoin_pcoinsTip = new Bitcoin_CCoinsViewCache(*bitcoin_pcoinsdbview);

        Bitcoin_InitBlockIndex();
        Credits_InitBlockIndex();

#ifdef ENABLE_WALLET
        bool fFirstRun;
        bitcoin_pwalletMain = new Bitcoin_CWallet("bitcoin_wallet.dat");
        bitcoin_pwalletMain->LoadWallet(fFirstRun);
        Bitcoin_RegisterWallet(bitcoin_pwalletMain);

        bitcredit_pwalletMain = new Credits_CWallet("credits_wallet.dat", &bitcredit_bitdb);
        bitcredit_pwalletMain->LoadWallet(fFirstRun, bitcredit_nAccountingEntryNumber);
        Bitcredit_RegisterWallet(bitcredit_pwalletMain);

        deposit_pwalletMain = new Credits_CWallet("deposit_wallet.dat", &deposit_bitdb);
        deposit_pwalletMain->LoadWallet(fFirstRun, deposit_nAccountingEntryNumber);
        Bitcredit_RegisterWallet(deposit_pwalletMain);
#endif
        bitcredit_nScriptCheckThreads = 3;
        for (int i=0; i < bitcredit_nScriptCheckThreads-1; i++)
            threadGroup.create_thread(&Bitcredit_ThreadScriptCheck);
        Bitcredit_RegisterNodeSignals(Credits_NetParams()->GetNodeSignals());
    }

void AsyncSpinnerImpl::start()
{
  boost::mutex::scoped_lock lock(mutex_);

  if (continue_)
    return;

  boost::recursive_mutex::scoped_try_lock spinlock(spinmutex);
  if (not spinlock.owns_lock()) {
    ROS_ERROR("AsyncSpinnerImpl: Attempt to call spin from multiple "
              "threads.  We already spin multithreaded.");
    return;
  }
  spinlock.swap(member_spinlock);

  continue_ = true;

  for (uint32_t i = 0; i < thread_count_; ++i)
  {
    threads_.create_thread(boost::bind(&AsyncSpinnerImpl::threadFunc, this));
  }
}

void init()
{
	// Initialize the DevIL framework.
	ilInit();

	// Initialize OpenGL
	glInit();

	// Give the scene a starting number of spheres.
	changeSphereCount(INITIAL_SPHERE_COUNT);
	
	// Create an image ID for our font texture.
	ILubyte fontId = ilGenImage();
	ilBindImage(fontId);

	if(!ilLoad(IL_PNG, "data/font.png"))
	{
		MessageBox(NULL, "Unable to load font texture.\nThere will be no interface.", "Could not load font.", MB_OK);
	}
	else
	{
		// Tell all existing TextFields the image ID to use.
		txtNumSpheres.setFontId(fontId);
		txtRenderFrames.setFontId(fontId);
		txtPhysicsFrames.setFontId(fontId);
		txtNumThreads.setFontId(fontId);

		txtInstructions.setFontId(fontId);
		txtInstructions.setColour(0xFFFFAA);
		txtInstructions.setText("Press +/- to add or remove spheres. 1 - 9 to set sphere size.");

		txtInstructions2.setFontId(fontId);
		txtInstructions2.setColour(0xFFFFAA);
		txtInstructions2.setText("Use the arrow keys and page up/down to control the sphere.");
	}

	int iCPUVals[4];
	cpuid(1, iCPUVals);

	bool sse4Support = false;
	if(iCPUVals[2] & (1 << 19))
	{
		sse4Support = true;
	}

#ifdef _SSE4
	if(!sse4Support && _SSE4)
	{
		txtInstructions.setColour(0xFF0000);
		txtInstructions.setText("Your computer does not support SSE4, please use a different version of this program.");
		displayError = true;

		numPhysicsThreads = 1;
	}
	else
#endif
	{
		// Setup performance checking, used to determine time difference
		// between physics thread runs.
		QueryPerformanceFrequency( &frequency );
		freq = (double)frequency.QuadPart / 1000.0;
		LARGE_INTEGER firstTime;
		QueryPerformanceCounter(&firstTime);

	#if _USE_MT
		// Get the number of physics threads to use from boost.
		numPhysicsThreads = boost::thread::hardware_concurrency();
	#else
		// Set that we're only using one thread, mostly for the purpose that
		// the physics function uses the number of threads for striding.
		numPhysicsThreads = 1;
	#endif

		updateTimes = new LARGE_INTEGER[numPhysicsThreads];
		physicsFrames = new int[numPhysicsThreads];

		for(int i = 0; i < numPhysicsThreads; i++)
		{
			updateTimes[i] = firstTime;
			physicsFrames[i] = 0;
	#if _USE_MT
			threads.create_thread(boost::bind(physicsThread, i));
	#endif
		}

		char buff[32];

		sprintf(buff, "Num threads: %d", numPhysicsThreads);
		txtNumThreads.setText(buff);
	}
}

int main(int argc, char **argv)
{

	// get and set locale language - BUG 5362
	string systemLang = "C";
	systemLang = funcexp::utf8::erydb_setlocale();

	BRM::logInit ( BRM::SubSystemLogId_workerNode );

	string nodeName;
	SlaveDBRMNode slave;
	string arg;
	int err = 0;
	ShmKeys keys;

	if (argc < 2) {
		ostringstream os;
		os << "Usage: " << argv[0] << " DBRM_WorkerN";
		cerr << os.str() << endl;
		log(os.str());
		fail();
		exit(1);
	}

	erydbdatafile::ERYDBPolicy::configERYDBPolicy();

	nodeName = argv[1];	
	try {
		comm = new SlaveComm(nodeName, &slave);
	}
	catch (exception &e) {
		ostringstream os;
		os << "An error occured: " << e.what();
		cerr << os.str() << endl;
		log(os.str());
		fail();
		exit(1);
	}
#ifdef SIGHUP
 	signal(SIGHUP, reset);
#endif
 	signal(SIGINT, stop);
	signal(SIGTERM, stop);
#ifdef SIGPIPE
	signal(SIGPIPE, SIG_IGN);
#endif

	if (!(argc >= 3 && (arg = argv[2]) == "fg"))
		err = fork();

	if (err == 0) {

		/* Start 4 threads to monitor write lock state */
		monitorThreads.create_thread(RWLockMonitor
				(&die, slave.getEMFLLockStatus(), keys.KEYRANGE_EMFREELIST_BASE));
		monitorThreads.create_thread(RWLockMonitor
				(&die, slave.getEMLockStatus(), keys.KEYRANGE_EXTENTMAP_BASE));
		monitorThreads.create_thread(RWLockMonitor
				(&die, slave.getVBBMLockStatus(), keys.KEYRANGE_VBBM_BASE));
		monitorThreads.create_thread(RWLockMonitor
				(&die, slave.getVSSLockStatus(), keys.KEYRANGE_VSS_BASE));

		try {
			oam::Oam oam;
			
			oam.processInitComplete("DBRMWorkerNode");
		}
		catch (exception &e) {
			ostringstream os;
			os << "failed to notify OAM: " << e.what();
			os << " continuing anyway";
			cerr << os.str() << endl;
			log(os.str(), logging::LOG_TYPE_WARNING);
		}

		try {
			comm->run();
		}
		catch (exception &e) {
			ostringstream os;
			os << "An error occurred: " << e.what();
			cerr << os.str() << endl;
			log(os.str());
			exit(1);
		}
	}
	else if (err < 0) {
		perror(argv[0]);
		log_errno(string(argv[0]));
		fail();
	}

	exit(0);
}

void exec(int id, bool threaded)
{
	if (threaded)
		std::cout << "thread:" << boost::this_thread::get_id() << ": " << id << std::endl;

	float* input = input_list[id];

#ifdef USE_OPENCL
	const cl::CommandQueue& queue = clQueues[id];
	const cl::Kernel& assignment = clClusterAssignment[id];
	const cl::Kernel& reposition = clClusterReposition[id];
	const cl::Kernel& reposition_k = clClusterReposition_k[id];
	const cl::Kernel& reposition_k_c = clClusterReposition_k_c[id];
	const cl::Kernel& cost = clComputeCost[id];

	const cl::Buffer& inputBuf = clInputBuf[id];
	const cl::Buffer& mappingBuf = clMappingBuf[id];
	const cl::Buffer& centroidBuf = clCentroidBuf[id];
	//const cl::Buffer& convergedBuf = clConvergedBuf[id];
	const cl::Buffer& reductionBuf = clReductionBuf[id];

	queue.enqueueWriteBuffer(inputBuf, CL_FALSE, 0, N * DIM * sizeof(float), (void*)input, NULL, NULL);
#endif

	for (int pass = id; pass < RUNS; pass += device_count) {

		float* reduction = new float[N];
		float* centroids = random_cluster_init(input);
		int* mapping = new int[N];
		centroids_list[pass] = centroids;
		mapping_list[pass] = mapping;

		util::Clock clock;
		clock.reset();

#ifdef USE_OPENCL
		queue.enqueueWriteBuffer(centroidBuf, CL_FALSE, 0, K * DIM * sizeof(float), (void*)centroids, NULL, NULL);

		for (int i = 0; i < ITERATIONS; ++i) {
			queue.enqueueNDRangeKernel(assignment, cl::NullRange, cl::NDRange(N), cl::NDRange(AM_LWS), NULL, NULL);

#ifdef CLUSTER_REPOSITION_K
			queue.enqueueNDRangeKernel(reposition_k, cl::NullRange, cl::NDRange(K), cl::NDRange(RP_LWS), NULL, NULL);
#else
			queue.enqueueNDRangeKernel(reposition, cl::NullRange, cl::NDRange(DIM), cl::NDRange(RP_LWS), NULL, NULL);
#endif
		}
		queue.enqueueNDRangeKernel(cost, cl::NullRange, cl::NDRange(N), cl::NDRange(CT_LWS), NULL, NULL);

		//queue.finish();

		queue.enqueueReadBuffer(centroidBuf, CL_FALSE, 0, K * DIM * sizeof(float), centroids, NULL, NULL);
		queue.enqueueReadBuffer(mappingBuf, CL_FALSE, 0, N * sizeof(int), mapping, NULL, NULL);
		queue.enqueueReadBuffer(reductionBuf, CL_TRUE, 0, N * sizeof(float), reduction, NULL, NULL);

		reduction_group.create_thread(boost::bind(reduce_cost, pass, reduction));


		//queue.finish();
#else
		for (int i = 0; i < ITERATIONS; ++i) {
			cluster_assignment(input, centroids, mapping);
			cluster_reposition(input, centroids, mapping);
			//if (cluster_reposition(input, centroids, mapping)) {
			//	std::cout << "Converged after " << i+1 << " iterations." << std::endl;
			//	break;
			//}
		}

		cost_list[pass] = cluster_compute_cost(input, centroids, mapping);
#endif

		float now = clock.get();
		std::cout << "Device: " << now << std::endl;
	}
/*
	float sum = 0.0f;
	for (int i = 0; i < N; ++i) {
		sum += treduction[i];
	}

	sum /= (float)N;

	std::cout << sum << std::endl;
*/
}

void M6Processor::Process(vector<fs::path>& inFiles, M6Progress& inProgress,
    uint32 inNrOfThreads)
{
    if (inFiles.size() >= inNrOfThreads)
        mUseDocQueue = false;
    else
    {
        mUseDocQueue = true;
        for (uint32 i = 0; i < inNrOfThreads; ++i)
            mDocThreads.create_thread([this]() { this->ProcessDocument(); });
    }

    if (inFiles.size() == 1)
    {
        M6DataSource data(inFiles.front(), inProgress);
        for (M6DataSource::iterator i = data.begin(); i != data.end(); ++i)
        {
            LOG(INFO, "M6Processor: processing file %s", i->mFilename.c_str());
            ProcessFile(i->mFilename, i->mStream);
            LOG(INFO, "M6Processor: done processing file %s", i->mFilename.c_str());
        }
    }
    else
    {
        if (inNrOfThreads > inFiles.size())
            inNrOfThreads = static_cast<uint32>(inFiles.size());

        for (uint32 i = 0; i < inNrOfThreads; ++i)
            mFileThreads.create_thread(
                [&inProgress, this]() { this->ProcessFile(inProgress); }
            );

        for (fs::path& file : inFiles)
        {
            if (not (mException == std::exception_ptr()))
                rethrow_exception(mException);

            if (not fs::exists(file))
            {
                cerr << "file missing: " << file << endl;
                continue;
            }

            mFileQueue.Put(file);
        }

        mFileQueue.Put(fs::path());

        // Now all the input files have been added to the queue.

        mFileThreads.join_all();
    }

    if (mUseDocQueue)
    {
        mDocQueue.Put(kSentinel);
        mDocThreads.join_all();
    }

    if (not (mException == std::exception_ptr()))
        rethrow_exception(mException);
}