void Scene::computeColorsAntialiasing(std::function<void(int, int, ColorCRef)> paint, int threadCount, int level) {
upto(threadCount, 1);
downto(threadCount, 4);
std::vector< std::vector <ColorFloat> > m(screen.width, std::vector<ColorFloat> (screen.height, ColorFloat()));
computeColors([paint, &m](int x, int y, ColorCRef c) { m[x][y] = c; paint(x, y, c); }, threadCount);
if (level > 1) {
for (int x = 1; x + 1 < screen.width; x++) {
for (int y = 1; y + 1 < screen.height; y++) {
int badness = 0;
for (int dx : {-1, 1})
for (int dy : {-1, 1})
badness += (m[x][y] - m[x + dx][y + dy]).norm();
if (badness > badnessLimit) {
paint(x, y, Color(255, 0, 0));
}
}
}
int taskCount = 10;
ThreadPool pool;
for (int t = 0; t < taskCount; t++)
pool.addTask([this, &paint, &m, level, t, taskCount]()
{ multiThreadAntialiasePart(paint, m, level, t, taskCount); });
pool.executeAll(threadCount);
}
}
void Server::serve(int port, int maxClients, int numThreads) {
// set up the server socket
debug("Server::serve -- initializing listening socket");
int serverId = this->initSocket(port);
// set up the client manager
debug("Server::serve -- setting up client manager");
ClientManager* mgr = new ClientManager(maxClients);
// set up the thread pool
debug("Server::serve -- setting up thread pool");
ThreadPool* pool = new ThreadPool(numThreads);
pool->run(&run, mgr);
// set up client
int clientId;
struct sockaddr_in client_addr;
socklen_t clientlen = sizeof(client_addr);
// accept clients
debug("Server::serve -- waiting for client");
while ((clientId = accept(serverId, (struct sockaddr *)&client_addr, &clientlen)) > 0) {
ClientProxy* client = new ClientProxy(clientId);
debug("Server::serve -- adding client to queue");
mgr->pushClient(client);
}
// close the server socket
debug("Server::serve -- closing server socket");
close(serverId);
// clean up some memory (even though this will likely not ever be reached)
delete mgr;
delete pool;
}
//-----------------------------------------------------------------------------
TEST(ThreadPool, Sequential_WithMPSCBoundedQueue) {
// add N jobs to the queue, and wait until all will be completed
// this test should be faster than Sequential_WithStdQueue
ThreadPool pool;
MPMCBoundedQueue<std::future<int>> queue(128);
const int repetitions = 100;
for (int i = 1; i <= repetitions; i++) {
queue.push(std::move(pool.process([i]() {
std::this_thread::sleep_for(std::chrono::milliseconds(20));
return i;
})));
}
int sum_actual = 0;
std::future<int> item;
while (queue.pop(item)) {
sum_actual += item.get();
}
auto sum = [](int n) -> int { return n * (n + 1) / 2; };
ASSERT_EQ(sum_actual, sum(repetitions));
}
int main(int argc, char **argv){
bool ret = true;
long size = sysconf(_SC_NPROCESSORS_ONLN);
cout<<"number of workers: "<<size<<endl;
ThreadPool p;
ret = p.Init(size, start_routine, arg);
if (!ret){
return -1;
}
ret = p.Start();
if (!ret){
p.Shutdown();
return -1;
}
int n = 3;
while(n-->0){
sleep(2);
}
p.Shutdown();
return 0;
}
void* ThreadPool::poll(void *arg) {
ThreadPool* ths = (ThreadPool*)arg;
while (true) {
if (!ths->prioritypooling) {
if (ths->wpool->tasksPending()) {
Task *task = ths->wpool->getTask();
PoolThread *idleThread = ths->getIdleThread();
idleThread->task = task;
idleThread->idle = false;
cout << "got task" << endl;
idleThread->mthread->interrupt();
} else {
Thread::mSleep(1);
}
} else {
if (ths->wpool->tasksPPending()) {
Task *task = ths->wpool->getPTask();
PoolThread *idleThread = ths->getIdleThread();
idleThread->task = task;
idleThread->idle = false;
idleThread->mthread->interrupt();
} else {
Thread::mSleep(1);
}
}
}
return NULL;
}
void render()
{
scene.beginFrame();
vector<Rect> buckets = getBucketsList();
if (!scene.settings.interactive && (scene.settings.wantPrepass || scene.settings.gi)) {
// We render the whole screen in three passes.
// 1) First pass - use very coarse resolution rendering, tracing a single ray for a 16x16 block:
for (Rect& r: buckets) {
for (int dy = 0; dy < r.h; dy += 16) {
int ey = min(r.h, dy + 16);
for (int dx = 0; dx < r.w; dx += 16) {
int ex = min(r.w, dx + 16);
Color c = raytraceSinglePixel(r.x0 + dx + ex / 2, r.y0 + dy + ey / 2);
if (!drawRect(Rect(r.x0 + dx, r.y0 + dy, r.x0 + ex, r.y0 + ey), c))
return;
}
}
}
}
MainRenderTask mtrend(buckets);
pool.run(&mtrend, scene.settings.numThreads);
if (scene.settings.needAApass()) {
// the previous render was without any anti-aliasing whatsoever, and the
// scene file specifies that AA is desired. Detect edges here, and refine in another pass:
detectAApixels(buckets);
RefineRenderTask refineTask(buckets);
pool.run(&refineTask, scene.settings.numThreads);
}
}
bool ApService::InitApService(std::string ApListenIp, int ApListenPort, int threadPoolNum) {
bool status = true;
_ApListenIp = ApListenIp;
_ApListenPort = ApListenPort;
_threadPoolNum = threadPoolNum;
SharedPointer<IProcessor> xp(
new apapiProcessor(
SharedPointer<apapi>(
new ApService)));
ServiceManager sm;
sm.add_service(xp);
ThreadPool tp;
tp.init(_threadPoolNum);
Server* server = new Server(&sm, &tp, _ApListenPort);
if (0 != server->serve()) {
status = false;
}
return status;
}
void testExecPerSecond(int numberOfThreads, int numberOfKeys)
{
ThreadPool<Task> pool;
pool.init(numberOfThreads, numberOfKeys, 10000);
for (long long int i = 0; ; ++i) {
Task t(i % numberOfKeys);
pool.enqueue(t);
if (i % 100000 == 0) {
int execCounterCur = execCounter.load();
int millisCur = getMilliseconds();
if (execCounterPrev != 0) {
int counterDif = execCounterCur - execCounterPrev;
long long int millisDif = millisCur - millisPrev;
long long int execPerSec = (counterDif / millisDif) * 1000;
cout << "exec per sec: " << execPerSec << "" << endl;
}
execCounterPrev = execCounterCur;
millisPrev = millisCur;
}
}
}
int testThreadPool()
{
#ifdef __LINUX__
cout << "this is linux" << endl;
#endif
#ifdef __WINDOWS__
cout << "this is windows" << endl;
#endif
ThreadPool pool;
pool.Run(8);
pool.AddTask(new MyTask());
MySignal si;
for (int i = 0; i < 8; ++i)
//while (running)
{
pool.AddTask(new MyTask());
cout << "add task ...." << endl;
//Timer::Sleep(500);
}
int sec = 0;
while (running)
{
cout << "wait sec " << sec++ << endl;
Timer::Sleep(1000);
}
return 0;
}
DWORD WINAPI ThreadPool::WorkerThread(LPVOID lpParam)
{
CoInitialize(NULL);
ThreadPool *obj = (ThreadPool *)lpParam;
CARBONLOG_CLASS_PTR logger(carbonLogger::getLoggerPtr());
CARBONLOG_INFO(logger, "[WorkerThread] : starting worker thread now..");
while(obj->shouldContinue)
{
std::string jobMsg, jobOutput;
if(obj->getJobMsg(jobMsg))
{
CARBONLOG_DEBUG(logger, "[WorkerThread] : Processing job ..");
processJob(jobMsg,jobOutput);
if(!obj->writeJobOutput(jobOutput))
CARBONLOG_ERROR(logger, "[WorkerThread] : Failed to write packet to BI");
}
else
Sleep(10);
}
CARBONLOG_INFO(logger, "[WorkerThread] : exiting worker thread now..");
CoUninitialize();
return 0;
}
void CpuNonbondedForce::calculateDirectIxn(int numberOfAtoms, float* posq, const vector<RealVec>& atomCoordinates, const vector<pair<float, float> >& atomParameters,
const vector<set<int> >& exclusions, vector<AlignedArray<float> >& threadForce, double* totalEnergy, ThreadPool& threads) {
// Record the parameters for the threads.
this->numberOfAtoms = numberOfAtoms;
this->posq = posq;
this->atomCoordinates = &atomCoordinates[0];
this->atomParameters = &atomParameters[0];
this->exclusions = &exclusions[0];
this->threadForce = &threadForce;
includeEnergy = (totalEnergy != NULL);
threadEnergy.resize(threads.getNumThreads());
gmx_atomic_t counter;
gmx_atomic_set(&counter, 0);
this->atomicCounter = &counter;
// Signal the threads to start running and wait for them to finish.
ComputeDirectTask task(*this);
threads.execute(task);
threads.waitForThreads();
// Combine the energies from all the threads.
if (totalEnergy != NULL) {
double directEnergy = 0;
int numThreads = threads.getNumThreads();
for (int i = 0; i < numThreads; i++)
directEnergy += threadEnergy[i];
*totalEnergy += directEnergy;
}
}
static void NO_INLINE execute(const Source & data, size_t num_threads, std::vector<std::unique_ptr<Map>> & results,
Creator && creator, Updater && updater,
ThreadPool & pool)
{
results.reserve(num_threads);
for (size_t i = 0; i < num_threads; ++i)
results.emplace_back(new Map);
for (size_t i = 0; i < num_threads; ++i)
{
auto begin = data.begin() + (data.size() * i) / num_threads;
auto end = data.begin() + (data.size() * (i + 1)) / num_threads;
auto & map = *results[i];
pool.schedule([&, begin, end]()
{
for (auto it = begin; it != end; ++it)
{
typename Map::iterator place;
bool inserted;
map.emplace(*it, place, inserted);
if (inserted)
creator(place->second);
else
updater(place->second);
}
});
}
pool.wait();
}
int main(int argc, char **args) {
int ret = log_init("./conf", "simple_log.conf");
if (ret != 0) {
printf("log init error!");
return 0;
}
if (argc < 2) {
LOG_ERROR("usage: ./http_multi_thread_demo [port]");
return -1;
}
pthread_key_create(&g_tp_key,NULL);
ThreadPool tp;
tp.set_thread_start_cb(test_start_fn);
tp.set_thread_exit_cb(test_exit_fn);
tp.set_pool_size(4);
HttpServer http_server;
http_server.set_thread_pool(&tp);
http_server.add_mapping("/hello", hello);
http_server.add_bind_ip("127.0.0.1");
http_server.set_port(atoi(args[1]));
http_server.set_backlog(100000);
http_server.set_max_events(100000);
http_server.start_async();
//sleep(1);
http_server.join();
return 0;
}
//-----------------------------------------------------------------------------
TEST(ThreadPool, Sequential_WithStdQueue) {
// add N jobs to the queue, and wait until all will be completed
ThreadPool pool;
std::queue<std::future<int>> queue;
const int repetitions = 100;
for (int i = 1; i <= repetitions; i++) {
queue.push(std::move(pool.process([i]() {
std::this_thread::sleep_for(std::chrono::milliseconds(20));
return i;
})));
}
int sum_actual = 0;
while (!queue.empty()) {
sum_actual += queue.front().get();
queue.pop();
}
auto sum = [](int n) -> int { return n * (n + 1) / 2; };
ASSERT_EQ(sum_actual, sum(repetitions));
}
void DoObjectLockTest( void )
{
cout << "Starting DoObjectLockTest" << endl;
LockableObjects & objects = GetLockableObjects();
objects.reserve( ObjectCount );
for ( unsigned int ii = 0; ii < ObjectCount; ++ii )
{
LockableObject * object = new LockableObject( ii );
objects.push_back( object );
}
{
ThreadPool pool;
pool.Create( ThreadCount, &RunObjectTest );
pool.Start();
pool.Join();
}
unsigned int totalFails = 0;
for ( unsigned int ii = 0; ii < ThreadCount; ++ii )
{
const unsigned int failCount = FailCounts[ ii ];
::Loki::Printf( "Thread: [%u] Failures: [%u]\n" )( ii )( failCount );
totalFails += failCount;
}
const char * result = ( 0 == totalFails ) ? "Passed" : "FAILED";
cout << "Finished DoObjectLockTest. Total Fails: " << totalFails << " Result: "
<< result << endl;
}
void run()
{
std::mt19937 generator(randomSeed());
std::uniform_int_distribution<size_t> distribution(0, queries.size() - 1);
for (size_t i = 0; i < concurrency; ++i)
pool.schedule(std::bind(&Benchmark::thread, this, connections.get()));
InterruptListener interrupt_listener;
info_per_interval.watch.restart();
delay_watch.restart();
/// Push queries into queue
for (size_t i = 0; !max_iterations || i < max_iterations; ++i)
{
size_t query_index = randomize ? distribution(generator) : i % queries.size();
if (!tryPushQueryInteractively(queries[query_index], interrupt_listener))
break;
}
shutdown = true;
pool.wait();
info_total.watch.stop();
if (!json_path.empty())
reportJSON(info_total, json_path);
printNumberOfQueriesExecuted(info_total.queries);
report(info_total);
}
unsigned RainbowTable::findPasswordByHash(unsigned* hash) {
int i;
Chain resultChain;
vector<vector<string> > result;
ThreadPool* myPool = new ThreadPool(THREADS_COUNT);
myPool->initializeThreads();
for (i = CHAIN_LENGTH - 1; i >= 0; --i) {
PasswordFindWorkerThread* myThread =
new PasswordFindWorkerThread(i, hash);
myPool->assignWork(myThread);
if (PasswordFindWorkerThread::result != 0) {
break;
}
}
myPool->destroyPool(1);
delete myPool;
printf("false alarm count: %d\n",
PasswordFindWorkerThread::falseAlarmCount);
if (PasswordFindWorkerThread::result != 0) {
return PasswordFindWorkerThread::result;
}
return 0;
}
int main (int argc, const char * argv[])
{
//Create a new thread pool
ThreadPool pool;
//Get the number of threads, this defaults to the number of threads on your machine
const unsigned int numThreads = pool.getThreadPoolSize();
//Set the number of tasks that we want to pass to the thread pool
const unsigned int numTasks = 100;
//Setup a vector to store the results
std::vector< double > results( numTasks );
std::vector< std::future< void > > status( numTasks );
//Add some tasks to the pool
for(unsigned int i=0; i<numTasks; i++){
status[i] = pool.enqueue( task, 99999, results[i] );
}
//Wait for the tasks to complex
for(unsigned int i=0; i<numTasks; i++){
status[i].wait();
}
//Get the maximum value across all the task results
double maxValue = results[0];
for(unsigned int i=1; i<numTasks; i++){
if( results[i] > maxValue ) maxValue = results[i];
}
infoLog << "maximum value: " << maxValue << std::endl;
return EXIT_SUCCESS;
}
FoundPoint percolate (const int size, ThreadPool& pool) {
std::vector<std::future<FoundPoint>> points;
FoundPoint max = FoundPoint();
int numThreads = pool.getSize();
int numOpThreadM = size/ numThreads;
int numOpThreadR = size % numThreads;
bool end = false;
for (int i = 0; i < numThreads; ++i) {
int startIndex = numOpThreadM * i;
int lastIndex = numOpThreadM * (i + 1);
if ((i + 1 == numThreads && numOpThreadR > 0)
|| numOpThreadM == 0) {
lastIndex += numOpThreadR;
end = true;
}
points.emplace_back(pool.enqueue_return(calc, startIndex,
lastIndex, size));
if (end) break;
}
for (auto& f: points) {
FoundPoint tmpFP = f.get();
if (tmpFP.value < max.value){
max = tmpFP;
}
}
return max;
}
int main()
{
std::string input;
std::string output;
double score;
corrector * corr = new corrector();
std::string cFile = "../Training/PrideAndPrejudice/PrideAndPrejudice.txt";
std::string tFile = "../Training/PrideAndPrejudice/tess2.txt";
corr->loadDictionary("../Dictionary/unigrams.txt");
corr->loadErrors("../trained5.txt");
//corr->learn(tFile, cFile);
//std::cout<<"learned"<<std::endl;
//corr->writeErrors("trained5.txt");
sqlite3 *db;
int rc;
rc = sqlite3_open("../Dictionary/BigramDatabase.db", &db);
if (rc)
{
std::cout<<"Can't open database"<<std::endl;
return 1;
}
std::string first = "0BEGIN.0";
double confidence;
ThreadPool tpool (4);
while (std::cin>>input)
{
//wordList = new std::list<entry>();
//corr->fillPossibleWordListLin(wordList, input, -20);
//entry e = wordList->front();
output = correct(input, corr, first, db, &tpool);
std::cout<<"returned"<<std::endl;
std::cout<<output<<std::endl;
/*output = Viterbi3( input, corr, db, 56000000, 50, 300);
std::cout<<"returned"<<std::endl;
std::cout<<output<<std::endl;*/
std::stringstream ss (output);
while (ss>>first);
//delete wordList;
}
tpool.shutdown();
delete corr;
return 0;
}
void __declspec(dllexport) GetSleep(LPVOID poolarg, LPVOID vectargs)
{
ThreadPool* pool =(ThreadPool*) poolarg;
std::vector<std::wstring>* vect = (std::vector<std::wstring>*) vectargs;
int count = _wtoi(vect->at(0).data());
for (int i = 0; i< count; i++)
pool->AddTask(WorkerGotDream,NULL);
}
void signalHandler(int sig) {
ThreadPool* pool = ThreadPool::Instance();
// JoinAll will deal with the memory de-allocation
// if all the threads are safely quited.
// so calling CancelAll here is fine
pool->CancelAll();
}
void TaskBlock::execute(ThreadPool& pool)
{
for(auto&&task : tasks)
pool.schedule_task(task);
pool.assist_until([this](){return done();});
//pool.print_accounts();
}
void *ThreadPool::threadFunc(void *args)
{
ThreadPool *pool = (ThreadPool *)args;
Task *task;
while (task = pool->getTask()) {
task->taskFunc(task->objArg, task->args);
delete task;
}
}
void Scene::computeColors(std::function<void(int, int, ColorCRef)> paint, int threadCount) {
figuresKDTree.init(figures);
upto(threadCount, 1);
downto(threadCount, 4);
int taskCount = 10;
ThreadPool pool;
for (int t = 0; t < taskCount; t++)
pool.addTask([this, &paint, t, taskCount]() { multiThreadComputePartOfColors(paint, t, taskCount); });
pool.executeAll(threadCount);
}
//-----------------------------------------------------------------------------
TEST(ThreadPool, ProcessJob) {
ThreadPool pool;
std::future<int> r = pool.process([]() {
std::this_thread::sleep_for(std::chrono::milliseconds(1));
return 42;
});
ASSERT_EQ(42, r.get());
}
int main() {
ThreadPool<Thread> *threadPool = new ThreadPool<Thread>(3);
for (int i = 0; i < 999; ++ i) {
usleep(1000 * 1000);
cout<<"add Task " << endl;
threadPool->addTask();
}
//threadPool->stop();
delete threadPool;
}
int
ACE_TMAIN(int argc, ACE_TCHAR *argv[])
{
try
{
CORBA::ORB_var orb = CORBA::ORB_init (argc, argv);
if (parse_args (argc, argv) != 0)
return 1;
CORBA::Object_var poa_object = orb->resolve_initial_references("RootPOA");
if (CORBA::is_nil (poa_object.in ()))
ACE_ERROR_RETURN ((LM_ERROR,
" (%P|%t) Unable to initialize the POA.\n"),
1);
PortableServer::POA_var root_poa = PortableServer::POA::_narrow (
poa_object.in ());
PortableServer::POAManager_var poa_manager =
root_poa->the_POAManager();
Subscriber_impl subscriber(orb.in ());
PortableServer::ObjectId_var id =
root_poa->activate_object (&subscriber);
CORBA::Object_var object = root_poa->id_to_reference (id.in ());
Subscriber_var subscriber_var = Subscriber::_narrow (object.in ());
object = orb->string_to_object(ior);
Publisher_var publisher = Publisher::_narrow(object.in());
publisher->subscribe(subscriber_var.in());
poa_manager->activate();
ThreadPool pool (orb.in ());
if (pool.activate(THR_NEW_LWP | THR_JOINABLE, 5) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
"Cannot activate client threads\n"),
1);
pool.thr_mgr ()->wait ();
ACE_DEBUG ((LM_DEBUG, "event loop finished\n"));
}
catch (const CORBA::Exception& ex)
{
ex._tao_print_exception ("Exception caught:");
return 1;
}
return 0;
}
int main()
{
Util::Title("Enqueued Work Items");
std::cout << "\n main thread id = " << std::this_thread::get_id();
ThreadPool<WorkResult> processor;
processor.start();
// define 1st work item
WorkItem<WorkResult> wi1 = []() {
std::cout << "\n working on thread " << std::this_thread::get_id();
return "Hello from wi1";
};
processor.doWork(&wi1);
// define 2nd work item
WorkItem<WorkResult> wi2 = []()
{
std::cout << "\n working on thread " << std::this_thread::get_id();
size_t sum = 0;
for (size_t i = 0; i < 100000; ++i)
sum += i;
return "wi2 result = " + Utilities::Converter<size_t>::toString(sum);
};
processor.doWork(&wi2);
// the following calls to result() block until results are enqueued
// define 3rd work item
WorkItem<WorkResult> wi3 = []() {
std::cout << "\n working on thread " << std::this_thread::get_id();
return "Hello from wi3";
};
processor.doWork(&wi3);
std::cout << "\n " << processor.result();
std::cout << "\n " << processor.result();
std::cout << "\n " << processor.result();
processor.doWork(nullptr);
processor.doWork(nullptr);
processor.doWork(nullptr);
// wait for child thread to complete
processor.wait();
std::cout << "\n\n";
}
void* start_thread(void* arg)
{
ThreadPool* tp = (ThreadPool *)arg;
if (tp->m_scb != NULL) {
tp->m_scb();
} else {
LOG_DEBUG("thread start cb is null");
}
tp->execute_thread();
return NULL;
}
