void Logger::storeLog(std::shared_ptr<StoredLog> && log)
{
for (auto & loggerOutputData : mLoggerOutputsData)
{
if (LoggerLevel::Off != loggerOutputData.second.level)
{
switch (loggerOutputData.second.level)
{
case LoggerLevel::Info:
{
if (ELogSeverity_Debug == log->severity)
{
break;
}
}
default:
{
if (LoggerOutput::GuiTable == loggerOutputData.first)
{
std::lock_guard<std::mutex> lockGuard(mStoredLogsGuiTableMtx);
loggerOutputData.second.storedLogs.push_back(log);
}
else if (LoggerOutput::SnapshotFile == loggerOutputData.first)
{
std::lock_guard<std::mutex> lockGuard(mStoredLogsSnapshotFileMtx);
loggerOutputData.second.storedLogs.push_back(log);
}
break;
}
}
}
}
}
void function_thread(SharedQueue<PointersStack<Stream>* >& queue) {
std::thread::id tid = std::this_thread::get_id();
PointersStack<Stream>* stack;
Stream* stream0, *stream1;
while (queue.alive()) {
{
std::lock_guard<std::mutex> lockGuard(cout_mutex);
std::cout << "Thread "
<< std::hex << std::uppercase << tid
<< std::nouppercase << std::dec
<< " starting game" << std::endl;
}
stack = queue.subtract();
stream0 = (*stack)[0];
stream1 = (*stack)[1];
// initial state
stream0->send("whte");
stream1->send("blck");
// communication between clients
std::string msg;
for (;;) {
msg = stream0->recv(MSG_SIZE);
if (msg.length() < 1) break; // end of stream
{
std::lock_guard<std::mutex> lockGuard(cout_mutex);
std::cout << "Thread "
<< std::hex << std::uppercase << tid
<< std::nouppercase << std::dec
<< " white -> black";
for (int i = 0; i < msg.length(); ++i)
std::cout << " " << (int)msg[i];
std::cout << std::endl;
}
stream1->send(msg);
msg = stream1->recv(MSG_SIZE);
if (msg.length() < 1) break; // end of stream
{
std::lock_guard<std::mutex> lockGuard(cout_mutex);
std::cout << "Thread "
<< std::hex << std::uppercase << tid
<< std::nouppercase << std::dec
<< " black -> white";
for (int i = 0; i < msg.length(); ++i)
std::cout << " " << (int)msg[i];
std::cout << std::endl;
}
stream0->send(msg);
}
delete stack;
}
}
// MANIPULATORS
bsl::shared_ptr<const Calendar>
CalendarCache::getCalendar(const char *calendarName)
{
BSLS_ASSERT(calendarName);
{
bsls::BslLockGuard lockGuard(&d_lock);
CacheIterator iter = d_cache.find(calendarName);
if (iter != d_cache.end()) {
if (!d_hasTimeOutFlag
|| !hasExpired(d_timeOut, iter->second.loadTime())) {
return iter->second.get(); // RETURN
}
else {
d_cache.erase(iter);
}
}
}
// Load calendar identified by 'calendarName'.
PackedCalendar packedCalendar; // temporary, so use default allocator
if (d_loader_p->load(&packedCalendar, calendarName)) {
return bsl::shared_ptr<const Calendar>(); // RETURN
}
// Create out-of-place calendar that will be managed by 'bsl::shared_ptr'.
Calendar *calendarPtr = new (*d_allocator_p) Calendar(packedCalendar,
d_allocator_p);
CalendarCache_Entry entry(calendarPtr, bsl::time(0), d_allocator_p);
BSLS_ASSERT(static_cast<bsl::time_t>(-1) != entry.loadTime());
// Insert newly-loaded calendar into cache if another thread hasn't done so
// already.
bsls::BslLockGuard lockGuard(&d_lock);
ConstCacheIterator iter = d_cache.find(calendarName);
// Here, we assume that the time elapsed between the last check and the
// loading of the calendar is insignificant compared to the timeout, so we
// will simply return the entry in the cache if it has been inserted by
// another thread.
if (iter != d_cache.end()) {
return iter->second.get(); // RETURN
}
d_cache[calendarName] = entry;
return entry.get();
}
bool ExperimentManager::setInputDataSource(EInputDataSource inputDataSource)
{
std::lock_guard<std::mutex> lockGuard(mMtx);
if (EExperimentState::Idle == mExperimentState)
{
mInputDataGenerator = InputDataGeneratorCreator::create(inputDataSource);
if (EInputDataSource::ExternalFile == inputDataSource)
{
Logger::info("%s: Set input data source for: External File!", getLoggerPrefix().c_str());
std::string filename = "";
DSC::DataManager::getUnitAttribute(EUnitId_Heater, "TestDataInputFilename", filename);
Logger::info("%s: File with inputData: %s.", getLoggerPrefix().c_str(), filename.c_str());
}
else
{
Logger::info("%s: Set input data source for: Uniform Distribution!", getLoggerPrefix().c_str());
}
mInputDataSource = inputDataSource;
return true;
}
else
{
Logger::warning("%s: Experiment is running. Cannot change input data source!", getLoggerPrefix().c_str());
return false;
}
}
void SocketSet::removeSocket(client::Socket const *socket) {
assert(NULL != socket);
int socketId = socket->getSocketId();
assert(socketId >= 0);
bool found = false;
if (socketId >= 0) {
LockGuard lockGuard(accessLock);
for (std::set<int>::const_iterator it = sockets.begin(); it != sockets.end(); it++) {
if (socketId == *it) { // found
sockets.erase(it);
found = true;
break;
}
}
}
if (!found) {
char msg[200];
util::snprintf(msg, 200,
"[SocketSet::removeSocket] Socket with id %d was not found among the sockets.",
socketId);
util::ILogger::getLogger().finest(msg);
}
}
void Logger::setLevel(LoggerOutput output, LoggerLevel level)
{
std::lock_guard<std::mutex> lockGuard(mDataMtx);
mLoggerOutputsData[output].level = level;
updateLoggerTimerStates();
}
size_t clear()
{
SpinLockGuard<Spin> lockGuard(m_spin);
size_t size = m_list.size();
m_list.clear();
return size;
}
void GamepadInput::setAxis(const int32_t axisIndex, const float value)
{
if (axisIndex < 0 || axisIndex >= VKTS_MAX_GAMEPAD_AXIS)
{
return;
}
std::lock_guard<std::mutex> lockGuard(mutexAxis);
if (value < VKTS_AXIS_DEAD_ZONE && value > -VKTS_AXIS_DEAD_ZONE)
{
axis[axisIndex] = 0.0f;
}
else if (value > 0.0f)
{
axis[axisIndex] = (value - VKTS_AXIS_DEAD_ZONE)
/ (1.0f - VKTS_AXIS_DEAD_ZONE);
}
else if (value < 0.0f)
{
axis[axisIndex] = (value + VKTS_AXIS_DEAD_ZONE)
/ (1.0f - VKTS_AXIS_DEAD_ZONE);
}
else
{
axis[axisIndex] = 0.0f;
}
}
nsresult OAuth2ThreadHelper::OnFailure(nsresult aError) {
MOZ_ASSERT(NS_IsMainThread(), "Can't touch JS off-main-thread");
MonitorAutoLock lockGuard(mMonitor);
mOAuth2String.Truncate();
mMonitor.Notify();
return NS_OK;
}
void ExperimentManager::validateInputData()
{
std::lock_guard<std::mutex> lockGuard(mMtx);
if (mInputDataGenerator)
{
mInputDataGenerator->validateInputData();
}
}
void sumUp(unsigned long long& sum, const std::vector<int>& val, unsigned long long beg, unsigned long long end){
unsigned long long tmpSum{};
for (auto i= beg; i < end; ++i){
tmpSum += val[i];
}
std::lock_guard<std::mutex> lockGuard(myMutex);
sum+= tmpSum;
}
VKAPI_ATTR VkBool32 VKAPI_CALL vktsDebugReportCallback(VkDebugReportFlagsEXT flags, VkDebugReportObjectTypeEXT objectType, uint64_t object, size_t location, int32_t messageCode, const char* pLayerPrefix, const char* pMessage, void* pUserData)
{
std::lock_guard<std::mutex> lockGuard(g_debugMutex);
logPrint(VKTS_LOG_INFO, "Debug: Flags 0x%x ObjectType %d Object %u Location %u MessageCode %d LayerPrefix '%s' Message '%s' UserData #%p", flags, objectType, object, location, messageCode, pLayerPrefix, pMessage, pUserData);
return VK_TRUE;
}
bool pushFront(const ElementType &value)
{
SpinLockGuard<Spin> lockGuard(m_spin);
if (m_list.size() < m_capacityCap) {
m_list.push_front(value);
return true;
}
return false;
}
void ThreadPool::Run(const Task& rTask) {
if (m_vThreads.empty()) {
rTask();
} else {
MutexLockGuard lockGuard(m_Mutex);
m_Queue.push_back(rTask);
m_Cond.Notify();
}
}
void Logger::updateGuiTable()
{
LoggerOutputData* loggerOutputData = nullptr;
{
std::lock_guard<std::mutex> lockGuard(mDataMtx);
loggerOutputData = &(mLoggerOutputsData[LoggerOutput::GuiTable]);
}
std::lock_guard<std::mutex> lockGuard(mStoredLogsGuiTableMtx);
for (const auto & storedLog : loggerOutputData->storedLogs)
{
if (mGuiTableLogCallback)
{
mGuiTableLogCallback(storedLog);
}
}
loggerOutputData->storedLogs.clear();
}
nsresult OAuth2ThreadHelper::OnSuccess(const nsACString &aOAuth2String) {
MOZ_ASSERT(NS_IsMainThread(), "Can't touch JS off-main-thread");
MonitorAutoLock lockGuard(mMonitor);
MOZ_ASSERT(mOAuth2Support, "Should not be here if no OAuth2 support");
mOAuth2String = aOAuth2String;
mMonitor.Notify();
return NS_OK;
}
void LogManagerImplementation::removeLogger(std::shared_ptr<Logger> logger)
{
std::lock_guard<std::mutex> lockGuard(m_loggerMutex);
std::vector<std::shared_ptr<Logger>>::iterator it = std::find(m_loggers.begin(), m_loggers.end(), logger);
if (it != m_loggers.end())
{
m_loggers.erase(it);
}
}
void KeyInput::resetKeys()
{
std::lock_guard<std::mutex> lockGuard(mutex);
for (int32_t keyIndex = 0; keyIndex < VKTS_MAX_KEYS; keyIndex++)
{
keys[keyIndex] = VK_FALSE;
}
}
ElementType popFront()
{
SpinLockGuard<Spin> lockGuard(m_spin);
if (m_list.empty()) {
return nullptr;
}
ElementType value = m_list.front();
m_list.pop_front();
return value;
}
int CalendarCache::invalidateAll()
{
bsls::BslLockGuard lockGuard(&d_lock);
const int numInvalidated = static_cast<int>(d_cache.size());
d_cache.clear();
return numInvalidated;
}
void Logger::setLevel(LoggerLevel level)
{
std::lock_guard<std::mutex> lockGuard(mDataMtx);
for (auto & loggerOutputData : mLoggerOutputsData)
{
loggerOutputData.second.level = level;
}
updateLoggerTimerStates();
}
float GamepadInput::getAxis(const int32_t axisIndex) const
{
if (axisIndex < 0 || axisIndex >= VKTS_MAX_GAMEPAD_AXIS)
{
return 0.0f;
}
std::lock_guard<std::mutex> lockGuard(mutexAxis);
return axis[axisIndex];
}
void GamepadInput::setButton(const int32_t buttonIndex, const VkBool32 pressed)
{
if (buttonIndex < 0 || buttonIndex >= VKTS_MAX_GAMEPAD_BUTTONS)
{
return;
}
std::lock_guard<std::mutex> lockGuard(mutexButtons);
buttons[buttonIndex] = pressed;
}
VkBool32 GamepadInput::getButton(const int32_t buttonIndex) const
{
if (buttonIndex < 0 || buttonIndex >= VKTS_MAX_GAMEPAD_BUTTONS)
{
return VK_FALSE;
}
std::lock_guard<std::mutex> lockGuard(mutexButtons);
return buttons[buttonIndex];
}
void EventLoopThread::threadFunc() {
EventLoop eventLoop;
{
MutexLockGuard lockGuard(m_Mutex);
m_pEventLoop = &eventLoop;
m_Cond.Notify();
}
eventLoop.Loop();
}
void KeyInput::setKey(const int32_t keyIndex, const VkBool32 pressed)
{
if (keyIndex < 0 || keyIndex >= VKTS_MAX_KEYS)
{
return;
}
std::lock_guard<std::mutex> lockGuard(mutex);
keys[keyIndex] = pressed;
}
VkBool32 KeyInput::getKey(const int32_t keyIndex) const
{
if (keyIndex < 0 || keyIndex >= VKTS_MAX_KEYS)
{
return VK_FALSE;
}
std::lock_guard<std::mutex> lockGuard(mutex);
return keys[keyIndex];
}
RecyclableHandlePool HandlePool::GetPool(Tag tag)
{
std::lock_guard<std::mutex> lockGuard(s_mutex);
if (tag != InvalidTag) {
for (auto iter : s_pools) {
if (iter.second.first->tag == tag) {
++iter.second.second;
return RecyclableHandlePool(
iter.second.first, [](std::shared_ptr<HandlePool> &pool) {
std::lock_guard<std::mutex> lockGuard(s_mutex);
const auto &iter = s_pools.find(pool->path);
if (--iter->second.second == 0) {
s_pools.erase(iter);
}
});
}
}
}
return RecyclableHandlePool(nullptr, nullptr);
}
void connection_manager::stop()
{
boost::mutex::scoped_lock lockGuard(mPoolMutex);
BOOST_FOREACH(connection_pool_t::value_type & weakConnection, mConnectionPool)
{
if (connection_base_ptr connection = weakConnection.second.lock())
{
connection->stop();
}
}
}
void Dispatcher::shutdown()
{
Task* task = createTask([this]() {
setState(THREAD_STATE_TERMINATED);
taskSignal.notify_one();
});
std::lock_guard<std::mutex> lockGuard(taskLock);
taskList.push_back(task);
taskSignal.notify_one();
}
