void Filter::use(
Filter::SharedDataLocker *locker,
const std::function<void ()> &cb,
const std::function<void ()> &rs)
{
if ( !workerThread() ){
cb();
rs();
} else if ( locker && locker->m_allLocked ){
workerThread()->postWork(cb, rs);
}
delete locker;
}
Database::Database( const QString& dbname, QObject* parent )
: QObject( parent )
, m_ready( false )
, m_impl( new DatabaseImpl( dbname ) )
, m_workerRW( new DatabaseWorkerThread( this, true ) )
, m_idWorker( new IdThreadWorker( this ) )
{
s_instance = this;
if ( MAX_WORKER_THREADS < DEFAULT_WORKER_THREADS )
m_maxConcurrentThreads = MAX_WORKER_THREADS;
else
m_maxConcurrentThreads = qBound( DEFAULT_WORKER_THREADS, QThread::idealThreadCount(), MAX_WORKER_THREADS );
tDebug() << Q_FUNC_INFO << "Using" << m_maxConcurrentThreads << "database worker threads";
connect( m_impl, SIGNAL( indexReady() ), SIGNAL( indexReady() ) );
connect( m_impl, SIGNAL( indexReady() ), SIGNAL( ready() ) );
connect( m_impl, SIGNAL( indexReady() ), SLOT( setIsReadyTrue() ) );
Q_ASSERT( m_workerRW );
m_workerRW.data()->start();
while ( m_workerThreads.count() < m_maxConcurrentThreads )
{
QPointer< DatabaseWorkerThread > workerThread( new DatabaseWorkerThread( this, false ) );
Q_ASSERT( workerThread );
workerThread.data()->start();
m_workerThreads << workerThread;
}
m_idWorker->start();
}
void* OperationQueue::Impl::onWorkerThread(void* data)
{
auto impl = (OperationQueue::Impl*)data;
impl->workerThread();
impl->release();
return nullptr;
}
void WebSharedWorkerImpl::connect(WebMessagePortChannel* webChannel, ConnectListener* listener)
{
workerThread()->runLoop().postTask(
createCallbackTask(&connectTask, adoptPtr(webChannel)));
if (listener)
listener->connected();
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "move_controller_node");
move_controller = new vigir_ocs::PSMoveTemplateController();
boost::thread workerThread(workerFunc);
while(ros::ok())
{
//hotkey_relay.onUpdate();
ros::spinOnce();
usleep(3000);
}
io_mutex.lock();
ros_down = true;
io_mutex.unlock();
workerThread.join();
delete move_controller;
return 0;
}
int main(int argc, char **argv)
{
ros::init(argc, argv, "image_raw");
ros::NodeHandle n;
image_transport::Publisher image_pub;
image_transport::ImageTransport it(n);
image_pub = it.advertise("image_raw", 1);
sensor_msgs::Image img_;
ros::Rate loop_rate(10);
PixyCam cam;
boost::thread workerThread(&PixyCam::run, &cam);
// cam.run();
int count = 0;
while (ros::ok()){
cv::Mat frame = cam.getImage();
fillImage(img_, "bgr8", frame.rows, frame.cols, frame.channels() * frame.cols, frame.data);
image_pub.publish(img_);
ros::spinOnce();
loop_rate.sleep();
++count;
}
return 0;
}
void WebSharedWorkerImpl::onScriptLoaderFinished()
{
ASSERT(m_loadingDocument);
ASSERT(m_mainScriptLoader);
if (m_askedToTerminate)
return;
if (m_mainScriptLoader->failed()) {
m_mainScriptLoader->cancel();
m_client->workerScriptLoadFailed();
// The SharedWorker was unable to load the initial script, so
// shut it down right here.
delete this;
return;
}
Document* document = m_mainFrame->frame()->document();
WorkerThreadStartMode startMode = DontPauseWorkerGlobalScopeOnStart;
if (InspectorInstrumentation::shouldPauseDedicatedWorkerOnStart(document))
startMode = PauseWorkerGlobalScopeOnStart;
// FIXME: this document's origin is pristine and without any extra privileges. (crbug.com/254993)
SecurityOrigin* starterOrigin = document->securityOrigin();
OwnPtrWillBeRawPtr<WorkerClients> workerClients = WorkerClients::create();
provideLocalFileSystemToWorker(workerClients.get(), LocalFileSystemClient::create());
WebSecurityOrigin webSecurityOrigin(m_loadingDocument->securityOrigin());
provideContentSettingsClientToWorker(workerClients.get(), adoptPtr(m_client->createWorkerContentSettingsClientProxy(webSecurityOrigin)));
RefPtrWillBeRawPtr<ContentSecurityPolicy> contentSecurityPolicy = m_mainScriptLoader->releaseContentSecurityPolicy();
OwnPtr<WorkerThreadStartupData> startupData = WorkerThreadStartupData::create(
m_url,
m_loadingDocument->userAgent(),
m_mainScriptLoader->script(),
nullptr,
startMode,
contentSecurityPolicy ? contentSecurityPolicy->headers() : nullptr,
starterOrigin,
workerClients.release());
m_loaderProxy = WorkerLoaderProxy::create(this);
setWorkerThread(SharedWorkerThread::create(m_name, m_loaderProxy, *this));
InspectorInstrumentation::scriptImported(m_loadingDocument.get(), m_mainScriptLoader->identifier(), m_mainScriptLoader->script());
m_mainScriptLoader.clear();
workerThread()->start(startupData.release());
m_workerInspectorProxy->workerThreadCreated(m_loadingDocument.get(), workerThread(), m_url);
m_client->workerScriptLoaded();
}
void WebSharedWorkerImpl::startWorkerContext(const WebURL& url, const WebString& name, const WebString& userAgent, const WebString& sourceCode, const WebString& contentSecurityPolicy, WebContentSecurityPolicyType policyType, long long)
{
initializeLoader(url);
WorkerThreadStartMode startMode = m_pauseWorkerContextOnStart ? PauseWorkerContextOnStart : DontPauseWorkerContextOnStart;
setWorkerThread(SharedWorkerThread::create(name, url, userAgent, sourceCode, *this, *this, startMode, contentSecurityPolicy,
static_cast<WebCore::ContentSecurityPolicy::HeaderType>(policyType)));
workerThread()->start();
}
void DiskLocation::fetchItems(QDir::Filter dirFilter, bool recursive)
{
DirListWorker *dlw = new DirListWorker(m_info->absoluteFilePath(), dirFilter, recursive);
connect(dlw, SIGNAL(itemsAdded(DirItemInfoList)),
this, SIGNAL(itemsAdded(DirItemInfoList)));
connect(dlw, SIGNAL(workerFinished()),
this, SLOT(onItemsFetched()));
workerThread()->addRequest(dlw);
}
int main(int argc, char* argv[])
{
std::cout << "main: startup" << std::endl;
Worker w = Worker();
boost::thread workerThread(w);
std::cout << "main: waiting for thread" << std::endl;
workerThread.join();
std::cout << "main: done" << std::endl;
return 0;
}
void WebWorkerImpl::startWorkerContext(const WebURL& scriptUrl,
const WebString& userAgent,
const WebString& sourceCode)
{
initializeLoader(scriptUrl);
setWorkerThread(DedicatedWorkerThread::create(scriptUrl, userAgent,
sourceCode, *this, *this));
// Worker initialization means a pending activity.
reportPendingActivity(true);
workerThread()->start();
}
//----------------------------------------------------------------------------------------
//Command worker thread control
//----------------------------------------------------------------------------------------
void DeviceContext::StartCommandWorkerThread(size_t deviceIndex, volatile ReferenceCounterType& remainingThreadCount, volatile ReferenceCounterType& suspendedThreadCount, std::mutex& commandMutex, std::condition_variable& commandSent, std::condition_variable& commandProcessed, IExecutionSuspendManager* asuspendManager, const DeviceContextCommand& command)
{
std::unique_lock<std::mutex> lock(commandMutex);
if(!commandWorkerThreadActive)
{
commandWorkerThreadActive = true;
std::thread workerThread(std::bind(std::mem_fn(&DeviceContext::CommandWorkerThread), this, deviceIndex, std::ref(remainingThreadCount), std::ref(suspendedThreadCount), std::ref(commandMutex), std::ref(commandSent), std::ref(commandProcessed), asuspendManager, std::ref(command)));
workerThread.detach();
commandThreadReady.wait(lock);
}
}
void WebSharedWorkerImpl::startWorkerContext(const WebURL& url, const WebString& name, const WebString& userAgent, const WebString& sourceCode, const WebString& contentSecurityPolicy, WebContentSecurityPolicyType policyType, long long)
{
initializeLoader(url);
WorkerThreadStartMode startMode = m_pauseWorkerContextOnStart ? PauseWorkerGlobalScopeOnStart : DontPauseWorkerGlobalScopeOnStart;
OwnPtr<WorkerClients> workerClients = WorkerClients::create();
provideLocalFileSystemToWorker(workerClients.get(), WorkerFileSystemClient::create());
OwnPtr<WorkerThreadStartupData> startupData = WorkerThreadStartupData::create(url, userAgent, sourceCode, startMode, contentSecurityPolicy, static_cast<WebCore::ContentSecurityPolicy::HeaderType>(policyType), workerClients.release());
setWorkerThread(SharedWorkerThread::create(name, *this, *this, startupData.release()));
workerThread()->start();
}
void startWithSourceCode(const String& source) {
std::unique_ptr<Vector<CSPHeaderAndType>> headers =
wrapUnique(new Vector<CSPHeaderAndType>());
CSPHeaderAndType headerAndType("contentSecurityPolicy",
ContentSecurityPolicyHeaderTypeReport);
headers->append(headerAndType);
workerThread()->start(WorkerThreadStartupData::create(
KURL(ParsedURLString, "http://fake.url/"), "fake user agent", source,
nullptr /* cachedMetaData */, DontPauseWorkerGlobalScopeOnStart,
headers.get(), "" /* referrerPolicy */, m_securityOrigin.get(),
nullptr /* workerClients */, WebAddressSpaceLocal,
nullptr /* originTrialTokens */, nullptr /* workerSettings */,
V8CacheOptionsDefault));
}
int main()
{
std::cout << "main: startup" << std::endl;
boost::thread workerThread(workerFunc);
std::cout << "main: waiting for thread" << std::endl;
workerThread.join();
std::cout << "main: done" << std::endl;
return 0;
}
void WebSharedWorkerImpl::connect(WebMessagePortChannel* webChannel, ConnectListener* listener)
{
// Convert the WebMessagePortChanel to a WebCore::MessagePortChannel.
RefPtr<PlatformMessagePortChannel> platform_channel =
PlatformMessagePortChannel::create(webChannel);
webChannel->setClient(platform_channel.get());
OwnPtr<MessagePortChannel> channel =
MessagePortChannel::create(platform_channel);
workerThread()->runLoop().postTask(
createCallbackTask(&connectTask, channel.release()));
if (listener)
listener->connected();
}
int main(int argc, char* argv[])
{
if (argc != 2)
{
std::cerr << "Usage: TCP_echo_server <port>\n";
return -1;
}
wiringPiSetup();
wiringPiI2CSetup(I2C_TEMP_ADDRESS);
boost::thread workerThread(listener_loop, std::atoi(argv[1])); // Creates a thread that loops to accept sockets
workerThread.join();
return 0;
}
void WebSharedWorkerImpl::startWorkerContext(const WebURL& url, const WebString& name, const WebString& userAgent, const WebString& sourceCode, const WebString& contentSecurityPolicy, WebContentSecurityPolicyType policyType, long long)
{
initializeLoader(url);
WorkerThreadStartMode startMode = m_pauseWorkerContextOnStart ? PauseWorkerContextOnStart : DontPauseWorkerContextOnStart;
ASSERT(m_loadingDocument->isDocument());
Document* document = static_cast<Document*>(m_loadingDocument.get());
GroupSettings* settings = 0;
if (document->page())
settings = document->page()->group().groupSettings();
setWorkerThread(SharedWorkerThread::create(name, url, userAgent, settings,
sourceCode, *this, *this, startMode, contentSecurityPolicy,
static_cast<WebCore::ContentSecurityPolicy::HeaderType>(policyType)));
workerThread()->start();
}
void DiskLocation::addExternalFsWorkerRequest(ExternalFileSystemChangesWorker *extFsWorker)
{
connect(extFsWorker, SIGNAL(added(DirItemInfo)),
this, SIGNAL(extWatcherItemAdded(DirItemInfo)));
connect(extFsWorker, SIGNAL(removed(DirItemInfo)),
this, SIGNAL(extWatcherItemRemoved(DirItemInfo)));
connect(extFsWorker, SIGNAL(changed(DirItemInfo)),
this, SIGNAL(extWatcherItemChanged(DirItemInfo)));
connect(extFsWorker, SIGNAL(finished(int)),
this, SIGNAL(extWatcherChangesFetched(int)));
workerThread()->addRequest(extFsWorker);
}
void scoring::MarkovNetworkScoreCalculator::calculateScores(FloatMap &cache) {
this->outOfTime = false;
boost::asio::io_service io_t;
t = new boost::asio::deadline_timer(io_t);
if (runningTime > 0) {
t->expires_from_now(boost::posix_time::seconds(runningTime));
t->async_wait(boost::bind(&scoring::MarkovNetworkScoreCalculator::timeout, this, boost::asio::placeholders::error));
boost::thread workerThread(boost::bind(&scoring::MarkovNetworkScoreCalculator::calculateScores_internal, this, boost::ref(cache)));
io_t.run();
workerThread.join();
io_t.stop();
} else {
calculateScores_internal(cache);
}
}
Database::Database( const QString& dbname, QObject* parent )
: QObject( parent )
, m_ready( false )
, m_impl( new DatabaseImpl( dbname ) )
, m_workerRW( new DatabaseWorkerThread( this, true ) )
, m_idWorker( new IdThreadWorker( this ) )
{
s_instance = this;
// register commands
registerCommand<DatabaseCommand_AddFiles>();
registerCommand<DatabaseCommand_DeleteFiles>();
registerCommand<DatabaseCommand_CreatePlaylist>();
registerCommand<DatabaseCommand_DeletePlaylist>();
registerCommand<DatabaseCommand_LogPlayback>();
registerCommand<DatabaseCommand_RenamePlaylist>();
registerCommand<DatabaseCommand_SetPlaylistRevision>();
registerCommand<DatabaseCommand_CreateDynamicPlaylist>();
registerCommand<DatabaseCommand_DeleteDynamicPlaylist>();
registerCommand<DatabaseCommand_SetDynamicPlaylistRevision>();
registerCommand<DatabaseCommand_SocialAction>();
registerCommand<DatabaseCommand_SetCollectionAttributes>();
registerCommand<DatabaseCommand_SetTrackAttributes>();
registerCommand<DatabaseCommand_ShareTrack>();
if ( MAX_WORKER_THREADS < DEFAULT_WORKER_THREADS )
m_maxConcurrentThreads = MAX_WORKER_THREADS;
else
m_maxConcurrentThreads = qBound( DEFAULT_WORKER_THREADS, QThread::idealThreadCount(), MAX_WORKER_THREADS );
tDebug() << Q_FUNC_INFO << "Using" << m_maxConcurrentThreads << "database worker threads";
connect( m_impl, SIGNAL( indexReady() ), SLOT( markAsReady() ) );
connect( m_impl, SIGNAL( indexReady() ), SIGNAL( indexReady() ) );
Q_ASSERT( m_workerRW );
m_workerRW.data()->start();
while ( m_workerThreads.count() < m_maxConcurrentThreads )
{
QPointer< DatabaseWorkerThread > workerThread( new DatabaseWorkerThread( this, false ) );
Q_ASSERT( workerThread );
workerThread.data()->start();
m_workerThreads << workerThread;
}
m_idWorker->start();
}
void MainWindow::released(){
if(btnSearch->text() == QString(ConstStrings::search)){
btnSearch->setText(QString(ConstStrings::cancel));
model->removeRows(0, model->rowCount());
int nFrom = txtFrom->text().toInt();
int nTo = txtTo->text().toInt();
thread = new QThread();
worker = new Worker(nFrom, nTo);
worker->moveToThread(thread);
workerThread();
thread->start();
}else{
worker->exit();
btnSearch->setText(QString(ConstStrings::search));
}
}
void WebWorkerImpl::postMessageToWorkerContext(const WebString& message,
const WebMessagePortChannelArray& webChannels)
{
OwnPtr<MessagePortChannelArray> channels;
if (webChannels.size()) {
channels = new MessagePortChannelArray(webChannels.size());
for (size_t i = 0; i < webChannels.size(); ++i) {
RefPtr<PlatformMessagePortChannel> platform_channel =
PlatformMessagePortChannel::create(webChannels[i]);
webChannels[i]->setClient(platform_channel.get());
(*channels)[i] = MessagePortChannel::create(platform_channel);
}
}
workerThread()->runLoop().postTask(
createCallbackTask(&postMessageToWorkerContextTask,
this, String(message), channels.release()));
}
TEST(WorkerThread_Test1, JustRun)
{
int a[5] = {11, 22, 33, 44, 55};
int b[5];
int size = _countof(a);
std::copy(&a[0], &a[_countof(a)], b);
TestWorker testWorker;
testWorker.Run();
Worker worker;
//WorkerThread<Worker, std::tr1::shared_ptr<Task> > workerThread(&worker, &Worker::RunMethod);
WorkerThread<Worker, Task > workerThread(&worker, &Worker::RunMemberMethod);
workerThread.Start();
//WorkerThread<Worker, Task > workerThread(&Worker::RunStaticMethod);
int numberOfTasks = 5;
for(int i = 0; i < numberOfTasks; ++i)
{
Task task(i);
//std::tr1::shared_ptr<Task> task(new Task(i));
workerThread.Enqueue(task);
//Sleep(1000);
}
//Sleep(3000);
workerThread.Stop();
workerThread.Stop();
//workerThread.TerminateGracefully();
workerThread.Join();
/*DWORD result = workerThread.Join(4000);
if(WAIT_OBJECT_0 != result)
workerThread.Terminate();
*/
//ASSERT_TRUE(worker.counter == numberOfTasks);
EXPECT_EQ(worker.counter, numberOfTasks);
}
RC_Widget::RC_Widget(bool block_Y,
int max_up_down, int min_up_down,
int max_left_right, int min_left_right,
int rev_up_down, int rev_left_right,
QWidget *parent) :
QWidget(parent)
{
if (pthread_mutex_init(&mutex, NULL) != 0){
std::cout << "mutex init failed" << std::endl;
}
QPalette pal_background;
pal_background.setColor(QPalette::Background, Qt::black);
setAutoFillBackground(true);
setPalette(pal_background);
setMaximumSize(500, 500);
setMinimumSize(500, 500);
press = false;
automatic = false;
this->block_Y = block_Y;
boost::thread workerThread(&RC_Widget::run, this);
connect(this, SIGNAL(update_GUI()), this, SLOT(on_update_GUI_recieved()));
p_actual.setX(250);
if(block_Y)
p_actual.setY(495);
else
p_actual.setY(250);
this->min_value_up_down = min_up_down;
this->max_value_up_down = max_up_down;
this->min_value_left_right = min_left_right;
this->max_value_left_right = max_left_right;
this->rev_left_right = rev_left_right;
this->rev_up_down = rev_up_down;
}
int main(int argc, char **argv)
{
#ifdef POINT_CLOUD
update = false;
boost::thread workerThread(visualize);
#endif
ros::init(argc, argv, "pfilterTest");
ros::NodeHandle n;
// ros::Publisher pub = n.advertise<geometry_msgs::PoseArray>("/particles_from_filter", 5);
ROS_INFO("Testing particle filter");
particleFilter::cspace b_Xprior[2];
computeInitialDistribution(b_Xprior, n);
PFilterTest pFilterTest(NUM_PARTICLES, b_Xprior);
ros::spin();
#ifdef POINT_CLOUD
workerThread.interrupt();
workerThread.join();
#endif
}
void WebSharedWorkerImpl::connect(WebMessagePortChannel* webChannel)
{
workerThread()->postTask(
BLINK_FROM_HERE, createCrossThreadTask(&connectTask, adoptPtr(webChannel)));
}
void WebSharedWorkerImpl::dispatchDevToolsMessage(const WebString& message)
{
workerThread()->runLoop().postTaskForMode(createCallbackTask(dispatchOnInspectorBackendTask, String(message)), WorkerDebuggerAgent::debuggerTaskMode);
}
void WebSharedWorkerImpl::detachDevTools()
{
workerThread()->runLoop().postTaskForMode(createCallbackTask(disconnectFromWorkerContextInspectorTask, true), WorkerDebuggerAgent::debuggerTaskMode);
}
void WebSharedWorkerImpl::reattachDevTools(const WebString& savedState)
{
workerThread()->runLoop().postTaskForMode(createCallbackTask(reconnectToWorkerContextInspectorTask, String(savedState)), WorkerDebuggerAgent::debuggerTaskMode);
}
