bool Thread::sleep(unsigned int time) { bool rval = true; // enter an arbitrary monitor Monitor m; m.enter(); { // wait to re-enter the monitor until the specified time uint32_t remaining = time; uint64_t st = System::getCurrentMilliseconds(); uint64_t et; uint64_t dt; while(rval && (time == 0 || remaining > 0)) { rval = waitToEnter(&m, remaining); if(rval && time > 0) { // update remaining time et = System::getCurrentMilliseconds(); dt = et - st; remaining = (dt >= remaining ? 0 : remaining - dt); st = et; } } } m.exit(); return rval; }
int main() { try { win.Read(NULL, 0); WugSSH ircsox; ircsox.BindProxy("wuggl.es", 22); ircsox.Bind("chat.freenode.net", 6667); CommandReader ui; Monitor iomon; iomon.Activate(); CommandReader *cr = (CommandReader *) iomon.AddDataSource(ui); WugSSH *wssh = (WugSSH *) iomon.ConnectDataSocket(ircsox); cr->ircsock = wssh; while (true) iomon.ServiceRoutine(Interval(1000, 0)); } catch (IOException &ioe) { wout.Write(String::ToString(ioe.errorcode) + "\n" + ioe.description + "\n"); } return 0; }
void Thread::interrupt() { lock(); // only interrupt if not already interrupted if(!isInterrupted()) { // set interrupted flag mInterrupted = true; // Note: disabled due to lack of support in windows // send SIGINT to thread //sendSignal(SIGINT); // store thread's current monitor Monitor* m = mWaitMonitor; unlock(); // wake up thread it is inside of a monitor if(m != NULL) { m->enter(); m->signalAll(); m->exit(); } } else { unlock(); } }
bool DisplayManager::IsFullscreen(HWND hWnd) { HWND fg = GetForegroundWindow(); if (hWnd == NULL || fg == NULL) { return false; } HWND shell = GetShellWindow(); if (fg == shell) { return false; } HWND dt = GetDesktopWindow(); if (fg == dt) { return false; } RECT wndRect = { 0 }; GetWindowRect(fg, &wndRect); Monitor wm = MonitorAtWindow(hWnd); if ((wndRect.bottom - wndRect.top) == wm.Height() && (wndRect.right - wndRect.left) == wm.Width()) { return true; } return false; }
MsgBufferModel::MsgBufferModel(QObject *parent) :QAbstractTableModel(parent) { /* Object Variables. */ lastValue = 0; /* GUI Refresh. */ timer = new QTimer(this); connect(timer, SIGNAL(timeout()), this, SLOT(timerHit())); timer->start(1000); /* Monitor Threads. */ QThread *threadx = new QThread; Monitor *monitor = new Monitor; connect(monitor, SIGNAL(messageInBuffer(canMessage*)), this, SLOT(newMsg(canMessage*))); connect(this, SIGNAL(start()), monitor, SLOT(start())); connect(this, SIGNAL(stop()), monitor, SLOT(stop())); monitor->moveToThread(threadx); threadx->start(); emit start(); }
~MutexUnlockerEx() { if (_no_safepoint_check == Mutex::_no_safepoint_check_flag) { _mutex->lock_without_safepoint_check(); } else { _mutex->lock(); } }
bool DirectoryMonitor::Server::addDirectory(const string& aPath) throw(MonitorException) { { RLock l(cs); if (monitors.find(aPath) != monitors.end()) return false; } init(); Monitor* mon = new Monitor(aPath, this, 0, 32 * 1024, true); try { mon->openDirectory(m_hIOCP); { WLock l(cs); mon->beginRead(); monitors.emplace(aPath, mon); failedDirectories.erase(aPath); } } catch (MonitorException& e) { mon->stopMonitoring(); delete mon; { WLock l(cs); failedDirectories.insert(aPath); } throw e; } return true; }
CFDataRef Monitor::receive_request(CFMessagePortRef local, SInt32 msgid, CFDataRef data, void *info) { Monitor *monitor = (Monitor *)info; CFIndex length = CFDataGetLength(data); memcpy(monitor->_request, CFDataGetBytePtr(data), length); CFDataRef reply = monitor->_response_buffer = CFDataCreateMutable(kCFAllocatorMallocZone, 0); // sample the stack. monitor->_stack_bottom = (void*) auto_get_sp(); // scan args monitor->tokenize_args(); // prevent the collector from collecting until we've processed the request. Zone *zone = Zone::zone(); if (zone) zone->block_collector(); // process request generating report monitor->process_request(); // unblock the collector. if (zone) zone->unblock_collector(); // return the response. CFDataAppendBytes(monitor->_response_buffer, (const UInt8*)"\0", 1); monitor->_response_buffer = NULL; return reply; }
static void *handle_connection(void *c) { size_t r_len = 1; Monitor *monitor = new Monitor(); Connection *conn = (Connection *)c; char *data = NULL; syslog(LOG_INFO, "accepted connection from engine: %s", conn->address()); while(r_len != 0) { try { data = conn->receive(data); if (r_len < 1 || data == NULL) continue; process_command(conn, monitor, data); free(data); data = NULL; } catch(char const* ex) { syslog(LOG_ERR, "%s", ex); continue; } } syslog(LOG_INFO, "disconnected from engine: %s", conn->address()); if (monitor != NULL) { monitor->terminate(); monitor->stop(); delete monitor; } conn->terminate(); delete conn; }
/* Given a jvmtiEnv* and jobject, find the Monitor instance or create one */ Monitor * Agent::get_monitor(jvmtiEnv *jvmti, JNIEnv *env, jobject object) { jvmtiError err; Monitor *m; jlong tag; m = NULL; tag = (jlong)0; err = jvmti->GetTag(object, &tag); check_jvmti_error(jvmti, err, "get tag"); /*LINTED*/ m = (Monitor *)(void *)(ptrdiff_t)tag; if ( m == NULL ) { m = new Monitor(jvmti, env, object); /* Save monitor on list */ if (monitor_count == monitor_list_size) { monitor_list_size += monitor_list_grow_size; monitor_list = (Monitor**)realloc((void*)monitor_list, (monitor_list_size)*(int)sizeof(Monitor*)); } monitor_list[monitor_count] = m; m->set_slot(monitor_count); monitor_count++; /*LINTED*/ tag = (jlong)(ptrdiff_t)(void *)m; err = jvmti->SetTag(object, tag); check_jvmti_error(jvmti, err, "set tag"); } return m; }
inline void Monitor::executor_callback(const char *name, NDArrayHandle handle, void *monitor_ptr) { Monitor *monitor = static_cast<Monitor*>(monitor_ptr); if (monitor->activated && std::regex_match(name, monitor->pattern)) { monitor->stats.emplace_back(monitor->step, name, monitor->stat_func(NDArray(handle))); } }
void run() { m.wait(); cout << "Done waiting in second thread." << endl; sleep_in_seconds(5); m.notify(); sleep_in_seconds(5); }
void MonitorTests::multiThreadedCallBackTest() { beginTest("Concurrent CallBack Test"); Monitor monitor; monitor.startMonitoring(); OwnedArray<SocketListener> listeners; for (int i = 0; i < 50 ; i++) { SocketListener* listener = new SocketListener(); listener->initializeSockets((40780 + (5*i)), &monitor, String("quassel") + String(i*20)); listeners.add(listener); } for (int i = 0; i < 50 ; i++) { pool->addJob(listeners[i], false); } while(pool->getNumJobs() > 0 ) { Thread::sleep(20); } monitor.stop(); for (int i = 0; i < 50 ; i++) { expectEquals(listeners[i]->was_informed , true); } }
void *MDnsSdListener::Monitor::threadStart(void *obj) { Monitor *monitor = reinterpret_cast<Monitor *>(obj); monitor->run(); delete monitor; pthread_exit(NULL); return NULL; }
static void malloc_block_recorder(task_t task, void *context, unsigned type, vm_range_t *range, unsigned count) { Monitor *monitor = reinterpret_cast<Monitor*>(context); for (unsigned i = 0; i < count; i++, range++) { monitor->print("block"); monitor->send_malloc_block_info((void*)range->address, range->size); monitor->print("\n"); } }
std::string Dashboard::Watch(const std::string& name) { std::lock_guard<std::mutex> l(m_); std::string result; if (record_.find(name) == record_.end()) return result; Monitor* monitor = record_[name]; CHECK_NOTNULL(monitor); return monitor->info_string(); }
void expireTest(int64_t numWorkers, int64_t expirationTimeMs) { int64_t maxPendingTasks = numWorkers; size_t activeTasks = numWorkers + maxPendingTasks; Monitor monitor; std::shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(numWorkers, maxPendingTasks); std::shared_ptr<PosixThreadFactory> threadFactory = std::shared_ptr<PosixThreadFactory>(new PosixThreadFactory()); threadManager->threadFactory(threadFactory); threadManager->setExpireCallback( std::bind(expireTestCallback, std::placeholders::_1, &monitor, &activeTasks)); threadManager->start(); // Add numWorkers + maxPendingTasks to fill up the ThreadManager's task queue std::vector<std::shared_ptr<BlockTask>> tasks; tasks.reserve(activeTasks); Monitor bmonitor; bool blocked = true; for (int64_t n = 0; n < numWorkers + maxPendingTasks; ++n) { std::shared_ptr<BlockTask> task(new BlockTask(&monitor, &bmonitor, &blocked, &activeTasks)); tasks.push_back(task); threadManager->add(task, 0, expirationTimeMs); } // Sleep for more than the expiration time usleep(expirationTimeMs * Util::US_PER_MS * 1.10); // Unblock the tasks { Synchronized s(bmonitor); blocked = false; bmonitor.notifyAll(); } // Wait for all tasks to complete or expire { Synchronized s(monitor); while (activeTasks != 0) { monitor.wait(); } } // The first numWorkers tasks should have completed, // the remaining ones should have expired without running size_t index = 0; for (const auto& task : tasks) { if (index < numWorkers) { BOOST_CHECK(tasks[index]->started_); } else { BOOST_CHECK(!tasks[index]->started_); } ++index; } }
void Kernel::serialize() { for (LMonitor::iterator it = monitors_->begin(); it != monitors_->end(); it++) { Monitor *monitor = *it; monitor->serialize(); } }
void Kernel::initWindows() { for (LMonitor::iterator it = monitors_->begin(); it != monitors_->end(); it++) { Monitor *monitor = (Monitor *)*it; monitor->scanWindows(); } }
/* This function is called once at start up ----------------------------------*/ void setup() { //Initialize the Monitor mon.begin(); //Set up the variables to be monitored mon.variable("robotSays",roboto,STRING); mon.variable("random",&rondo,INT); }
Thread_Impl(concurrent_queue<Task *> &q, Monitor &mon) : queue(q) , monitor(mon.GetMutex()) , live(true) , started(false) , thread(ThreadFunction, ThreadFunctionArg(*this, started)) { while(!started){ monitor.NotifyAll(); } }
void MonitorManager::updateAudioIcons() { Monitor *m = static_cast<Monitor *> (m_activeMonitor); if (!m) return; int volume = m->render->volume(); m_muteAction->blockSignals(true); m_muteAction->setChecked(volume == 0); m_muteAction->blockSignals(false); m->mute(volume == 0, true); }
void Kernel::updateBars() { for (LMonitor::iterator it = monitors_->begin(); it != monitors_->end(); it++) { Monitor *monitor = (Monitor *)*it; monitor->statusBar()->illuminate(); monitor->clientBar()->illuminate(); } }
int main(int argc, char* argv[]) { Monitor<std::stringstream> ss; std::vector<std::thread> threads; threads.emplace_back([&]() { ss([](auto& ss) { ss << "Hello 1 : " << std::this_thread::get_id() << std::endl; }); }); threads.emplace_back([&]() { ss([](auto& ss) { ss << "Hello 2 : " << std::this_thread::get_id() << std::endl; }); }); threads.emplace_back([&]() { ss([](auto& ss) { ss << "Hello 3 : " << std::this_thread::get_id() << std::endl; }); }); threads.emplace_back([&]() { ss([](auto& ss) { ss << "Hello 4 : " << std::this_thread::get_id() << std::endl; }); }); for (auto& t : threads) { t.join(); } ss([](auto& ss){ std::cout << ss.str() << std::endl; }); }
MutexLockerEx(Monitor * mutex, bool no_safepoint_check = !Mutex::_no_safepoint_check_flag) { _mutex = mutex; if (_mutex != NULL) { assert(mutex->rank() > Mutex::special || no_safepoint_check, "Mutexes with rank special or lower should not do safepoint checks"); if (no_safepoint_check) _mutex->lock_without_safepoint_check(); else _mutex->lock(); } }
int main(int argc, char* argv[]) { Monitor monitor; monitor.Initialize(); if (monapi_notify_server_start("INIT") != M_OK) { exit(-1); } monitor.Service(); return 0; }
void Kernel::grabShortcutOnAllMonitors(Shortcut *shortcut) { Binder *bm = Binder::instance(); for (LMonitor::iterator it = monitors_->begin(); it != monitors_->end(); it++) { Monitor *monitor = (Monitor *)*it; bm->grabShortcut(shortcut, monitor->rootWindow()); } }
int main (int argc, char *argv[]) { Thread t; t.start(*new MarkTime); sleep_in_seconds(5); m.notify(); m.wait(); cout << "Done waiting in main thread." << endl; t.lock(); return 0; // It will take a while for the return to complete, because it // locks t, which waits on the completion of its thread. }
void go2sleep(int thread, int seconds) { Monitor m; Synchronized s(m); for (int i = 0; i < seconds; ++i) { fprintf(stderr, "Thread %d: sleep %d\n", thread, i); try { m.wait(1000); } catch(const TimedOutException&) { } } fprintf(stderr, "THREAD %d DONE\n", thread); }
void Kernel::initKeys() { XCORE->ungrabKeyboard(); Binder *bm = Binder::instance(); for (LMonitor::iterator it = monitors_->begin(); it != monitors_->end(); it++) { Monitor *monitor = (Monitor *)*it; bm->initKeys(monitor->rootWindow()); } }