void Renderer::GatherRadianceFromLightWithShadowMap(const Avpl& avpl, CRenderTarget* pRenderTarget)
{
FillShadowMap(avpl);
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE);
glViewport(0, 0, m_camera->GetWidth(), m_camera->GetHeight());
COGLBindLock lockProgram(m_gatherRadianceWithSMProgram->GetGLProgram(), COGL_PROGRAM_SLOT);
AVPL_STRUCT light_info;
m_ubLight->UpdateData(&light_info);
CRenderTargetLock lock(pRenderTarget);
COGLBindLock lock0(m_shadowMap->GetShadowMapTexture(), COGL_TEXTURE0_SLOT);
COGLBindLock lock1(m_gbuffer->GetPositionTextureWS(), COGL_TEXTURE1_SLOT);
COGLBindLock lock2(m_gbuffer->GetNormalTexture(), COGL_TEXTURE2_SLOT);
COGLBindLock lock3(m_scene->GetMaterialBuffer()->GetOGLMaterialBuffer(), COGL_TEXTURE3_SLOT);
m_fullScreenQuad->draw();
glEnable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
void CachePaths()
{
std::lock_guard<std::mutex> lock1(CachedResourcesPathMutex);
std::lock_guard<std::mutex> lock2(CachedDocumentsPathMutex);
std::lock_guard<std::mutex> lock3(CachedWritablePathMutex);
CachedResourcesPath = GetPureResourcesPath();
CachedDocumentsPath = GetPureDocumentsPath();
CachedWritablePath = GetPureWritablePath();
}
void TCPConnection::ClearBuffers() {
LockMutex lock1(&MSendQueue);
LockMutex lock3(&MRunLoop);
LockMutex lock4(&MState);
safe_delete_array(recvbuf);
safe_delete_array(sendbuf);
char* line = 0;
while ((line = LineOutQueue.pop()))
safe_delete_array(line);
}
int main()
{
boost::detail::lightweight_mutex::scoped_lock lock1( m1 );
boost::detail::lightweight_mutex m2;
boost::detail::lightweight_mutex m3;
boost::detail::lightweight_mutex::scoped_lock lock2( m2 );
boost::detail::lightweight_mutex::scoped_lock lock3( m3 );
return 0;
}
void ServiceRegistration::SetProperties(const ServiceProperties& props)
{
if (!d) throw std::logic_error("ServiceRegistration object invalid");
MutexLocker lock(d->eventLock);
ServiceListeners::ServiceListenerEntries before;
// TBD, optimize the locking of services
{
//MutexLocker lock2(d->module->coreCtx->globalFwLock);
if (d->available)
{
// NYI! Optimize the MODIFIED_ENDMATCH code
int old_rank = 0;
int new_rank = 0;
std::list<std::string> classes;
{
MutexLocker lock3(d->propsLock);
Any any = d->properties[ServiceConstants::SERVICE_RANKING()];
if (any.Type() == typeid(int)) old_rank = any_cast<int>(any);
d->module->coreCtx->listeners.GetMatchingServiceListeners(d->reference, before, false);
classes = ref_any_cast<std::list<std::string> >(d->properties[ServiceConstants::OBJECTCLASS()]);
long int sid = any_cast<long int>(d->properties[ServiceConstants::SERVICE_ID()]);
d->properties = ServiceRegistry::CreateServiceProperties(props, classes, sid);
any = d->properties[ServiceConstants::SERVICE_RANKING()];
if (any.Type() == typeid(int)) new_rank = any_cast<int>(any);
}
if (old_rank != new_rank)
{
d->module->coreCtx->services.UpdateServiceRegistrationOrder(*this, classes);
}
}
else
{
throw std::logic_error("Service is unregistered");
}
}
ServiceListeners::ServiceListenerEntries matchingListeners;
d->module->coreCtx->listeners.GetMatchingServiceListeners(d->reference, matchingListeners);
d->module->coreCtx->listeners.ServiceChanged(matchingListeners,
ServiceEvent(ServiceEvent::MODIFIED, d->reference),
before);
d->module->coreCtx->listeners.ServiceChanged(before,
ServiceEvent(ServiceEvent::MODIFIED_ENDMATCH, d->reference));
}
double LanguageModel::getKLD(
LanguageModel *p, AbstractLanguageModel *q, AbstractLanguageModel *backgroundModel) {
LocalLock lock1(p);
LocalLock lock2(q);
LocalLock lock3(backgroundModel);
double result = 0.0;
double coverage = 0.0;
for (int i = 0; i < p->termSlotsUsed; i++) {
char *term = p->terms[i].term;
double bX = backgroundModel->getTermProbability(term);
if (bX < 1E-10)
continue;
double pX = 0.8 * p->terms[i].termFrequency / p->corpusSize + 0.2 * bX;
double qX = 0.8 * q->getTermProbability(term) + 0.2 * bX;
coverage += pX;
result += pX * log(pX / qX);
}
return result / coverage;
} // end of getKLD(LanguageModel*, AbstractLanguageModel*^2)
void MapPoint::UpdateNormalAndDepth()
{
map<KeyFrame*,size_t> observations;
KeyFrame* pRefKF;
cv::Mat Pos;
{
boost::mutex::scoped_lock lock1(mMutexFeatures);
boost::mutex::scoped_lock lock2(mMutexPos);
if(mbBad)
return;
observations=mObservations;
pRefKF=mpRefKF;
Pos = mWorldPos.clone();
}
cv::Mat normal = cv::Mat::zeros(3,1,CV_32F);
int n=0;
for(map<KeyFrame*,size_t>::iterator mit=observations.begin(), mend=observations.end(); mit!=mend; mit++)
{
KeyFrame* pKF = mit->first;
cv::Mat Owi = pKF->GetCameraCenter();
cv::Mat normali = mWorldPos - Owi;
normal = normal + normali/cv::norm(normali);
n++;
}
cv::Mat PC = Pos - pRefKF->GetCameraCenter();
const float dist = cv::norm(PC);
const int level = pRefKF->GetKeyPointScaleLevel(observations[pRefKF]);
const float scaleFactor = pRefKF->GetScaleFactor();
const float levelScaleFactor = pRefKF->GetScaleFactor(level);
const int nLevels = pRefKF->GetScaleLevels();
{
boost::mutex::scoped_lock lock3(mMutexPos);
mfMinDistance = (1.0f/scaleFactor)*dist / levelScaleFactor;
mfMaxDistance = scaleFactor*dist * pRefKF->GetScaleFactor(nLevels-1-level);
mNormalVector = normal/n;
}
}
void CResManage::ClearAllResource()
{
map<HWND, list<VideoRender*> > mapRander;
CSingleZenoLock lock1(m_mtxRander);
mapRander.swap(m_mapRander);
lock1.release();
for (map<HWND, list<VideoRender*> >::iterator iter = mapRander.begin();iter != mapRander.end();++iter)
{
list<VideoRender*>& listRander = iter->second;
for (list<VideoRender*>::iterator iter1 = listRander.begin();iter1 != listRander.end();++iter1)
{
delete *iter1;
}
}
list<int> listPort[StreamSourceType_Num];
CSingleZenoLock lock2(m_mtxPort);
for (int i = 0;i < StreamSourceType_Num;i++)
{
listPort[i].swap(m_listPort[i]);
}
lock2.release();
for (int i = 0;i < StreamSourceType_Num;i++)
{
for (list<int>::iterator iter = listPort[i].begin();iter != listPort[i].end();++iter)
{
PlaySDK_CloseStream(i, *iter);
CNBPlayer::UnusePort(i, *iter);
}
}
list<char*> listBuf;
CSingleZenoLock lock3(m_mtxFrameBuffer);
listBuf.swap(m_listFrameBuffer);
lock3.release();
for (list<char*>::iterator iter = listBuf.begin();iter != listBuf.end();++iter)
{
delete *iter;
}
}
void ctkServiceRegistration::setProperties(const ServiceProperties& props)
{
Q_D(ctkServiceRegistration);
if (!d) throw std::logic_error("ctkServiceRegistration object invalid");
QMutexLocker lock(&d->eventLock);
QSet<ctkServiceSlotEntry> before;
// TBD, optimize the locking of services
{
QMutexLocker lock2(&d->plugin->fwCtx->globalFwLock);
QMutexLocker lock3(&d->propsLock);
if (d->available)
{
// NYI! Optimize the MODIFIED_ENDMATCH code
int old_rank = d->properties.value(ctkPluginConstants::SERVICE_RANKING).toInt();
before = d->plugin->fwCtx->listeners.getMatchingServiceSlots(d->reference);
QStringList classes = d->properties.value(ctkPluginConstants::OBJECTCLASS).toStringList();
qlonglong sid = d->properties.value(ctkPluginConstants::SERVICE_ID).toLongLong();
d->properties = ctkServices::createServiceProperties(props, classes, sid);
int new_rank = d->properties.value(ctkPluginConstants::SERVICE_RANKING).toInt();
if (old_rank != new_rank)
{
d->plugin->fwCtx->services->updateServiceRegistrationOrder(*this, classes);
}
}
else
{
throw std::logic_error("Service is unregistered");
}
}
d->plugin->fwCtx->listeners.serviceChanged(
d->plugin->fwCtx->listeners.getMatchingServiceSlots(d->reference),
ctkServiceEvent(ctkServiceEvent::MODIFIED, d->reference), before);
d->plugin->fwCtx->listeners.serviceChanged(
before,
ctkServiceEvent(ctkServiceEvent::MODIFIED_ENDMATCH, d->reference));
}
boost::optional<std::pair<std::shared_ptr<MasterNode>, std::string>>
Master::bindClientToDomain(const std::shared_ptr<MasterClient>& client)
{
using RetType = std::pair<std::shared_ptr<MasterNode>, std::string>;
auto room = client->room();
std::vector<Balancer<RetType>::Item> items;
{
std::lock_guard<std::recursive_mutex> lock(nodeConnectionsMutex);
std::lock_guard<std::recursive_mutex> lock2(nodeThrottlesMutex);
std::lock_guard<std::recursive_mutex> lock3(versionsMutex);
for (const auto& c: nodes) {
auto node = c.second;
if (!node->isConnected())
continue;
// Has room?
auto verOrNone = node->findDomainForRoom(room);
if (verOrNone) {
auto ver = *verOrNone;
if (client->doesAcceptVersion(ver))
return RetType(node, ver);
}
// Get node throttle value
auto it = nodeThrottles.find(node->nodeInfo().nodeName);
if (it == nodeThrottles.end())
continue;
double nodeThrottle = it->second;
if (nodeThrottle <= 0.0)
continue;
// For every domains of the node...
for (const auto& domain: node->domainStatuses()) {
auto it2 = versions.find(domain.versionName);
if (it2 == versions.end())
continue;
// Get version throttle value
double versionThrottle = it2->second.throttle;
if (versionThrottle <= 0.0)
continue;
// Client accepts the version?
if (!client->doesAcceptVersion(it2->first))
continue;
// Add as balancer item
Balancer<RetType>::Item item;
item.key = RetType(node, domain.versionName);
item.current = static_cast<double>(domain.numClients);
item.desired = nodeThrottle * versionThrottle;
items.emplace_back(std::move(item));
}
}
}
// Invoke balancer
return Balancer<RetType>().performBalancing(items);
}
TEST(RwLock, Kind)
{
RwLock lock1(RwLock::kKindPreferReader);
RwLock lock2(RwLock::kKindPreferWriter);
RwLock lock3(RwLock::kKindDefault);
}
bool TCPConnection::ConnectIP(uint32 in_ip, uint16 in_port, char* errbuf)
{
if (errbuf)
{
errbuf[0] = 0;
}
if (ConnectionType != Outgoing)
{
// If this code runs, we got serious problems
// Crash and burn.
return false;
}
MState.lock();
if (ConnectReady())
{
pState = TCPS_Connecting;
}
else
{
MState.unlock();
SetAsyncConnect(false);
return false;
}
MState.unlock();
if (!pRunLoop)
{
pRunLoop = true;
#ifdef _WINDOWS
_beginthread(TCPConnectionLoop, 0, this);
#else
pthread_t thread;
pthread_create(&thread, nullptr, TCPConnectionLoop, this);
#endif
}
connection_socket = INVALID_SOCKET;
struct sockaddr_in server_sin;
if ((connection_socket = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET || connection_socket == 0)
{
#ifdef _WINDOWS
if (errbuf)
{
snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): Allocating socket failed. Error: %i", WSAGetLastError());
#else
if (errbuf)
{
snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): Allocating socket failed. Error: %s", strerror(errno));
#endif
}
SetState(TCPS_Ready);
SetAsyncConnect(false);
return false;
}
server_sin.sin_family = AF_INET;
server_sin.sin_addr.s_addr = in_ip;
server_sin.sin_port = htons(in_port);
// Establish a connection to the server socket.
#ifdef _WINDOWS
if (connect(connection_socket, (PSOCKADDR) &server_sin, sizeof (server_sin)) == SOCKET_ERROR)
{
if (errbuf)
{
snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): connect() failed. Error: %i", WSAGetLastError());
}
closesocket(connection_socket);
connection_socket = 0;
SetState(TCPS_Ready);
SetAsyncConnect(false);
return false;
}
#else
if (connect(connection_socket, (struct sockaddr *) &server_sin, sizeof (server_sin)) == SOCKET_ERROR)
{
if (errbuf)
{
snprintf(errbuf, TCPConnection_ErrorBufferSize, "TCPConnection::Connect(): connect() failed. Error: %s", strerror(errno));
}
close(connection_socket);
connection_socket = 0;
SetState(TCPS_Ready);
SetAsyncConnect(false);
return false;
}
#endif
int bufsize = 64 * 1024; // 64kbyte receive buffer, up from default of 8k
setsockopt(connection_socket, SOL_SOCKET, SO_RCVBUF, (char*) &bufsize, sizeof(bufsize));
#ifdef _WINDOWS
unsigned long nonblocking = 1;
ioctlsocket(connection_socket, FIONBIO, &nonblocking);
#else
fcntl(connection_socket, F_SETFL, O_NONBLOCK);
#endif
SetEcho(false);
ClearBuffers();
rIP = in_ip;
rPort = in_port;
SetState(TCPS_Connected);
SetAsyncConnect(false);
return true;
}
void TCPConnection::ClearBuffers()
{
LockMutex lock1(&MSendQueue);
LockMutex lock3(&MRunLoop);
LockMutex lock4(&MState);
safe_delete_array(recvbuf);
safe_delete_array(sendbuf);
char* line = 0;
while ((line = LineOutQueue.pop()))
{
safe_delete_array(line);
}
}
static void Test_SingleProcess()
{
LOG_POST("=== Single-process test ===");
const CTimeout zero_timeout = CTimeout(0,0);
LOG_POST("\n--- Test 1");
// Name test
{{
try {
CInterProcessLock lock("");
} catch (CInterProcessLockException&) {}
try {
CInterProcessLock lock("relative/path");
} catch (CInterProcessLockException&) {}
{{
CInterProcessLock lock("name");
assert(lock.GetName() == "name");
#if defined(NCBI_OS_UNIX)
assert(lock.GetSystemName() == "/var/tmp/name");
#elif defined(NCBI_OS_MSWIN)
assert(lock.GetSystemName() == "name");
#endif
}}
}}
// Fixed names are usually more appropriate, but here we don't
// want independent tests to step on each other...
string lockname = CFile::GetTmpName();
CInterProcessLock lock1(lockname);
CInterProcessLock lock2(lockname);
CInterProcessLock lock3(lockname);
LOG_POST("lock name = " << lock1.GetName());
LOG_POST("lock system name = " << lock1.GetSystemName());
LOG_POST("\n--- Test 2");
// Direct CInterProcessLock usage
{{
lock1.Lock(/*infinite*/);
try {
lock2.Lock(zero_timeout);
assert(0);
}
catch (CInterProcessLockException&) {}
assert( !lock2.TryLock() );
lock1.Unlock();
lock2.Lock(/*infinite*/);
assert( !lock3.TryLock() );
lock2.Unlock();
lock1.Lock(zero_timeout);
lock1.Remove();
// everything unlocked
}}
LOG_POST("\n--- Test 3");
// CGuard usage
{{
{{
CGuard<CInterProcessLock> GUARD(lock1);
try {
lock2.Lock(zero_timeout);
assert(0);
}
catch (CInterProcessLockException&) {}
}}
lock2.Lock(zero_timeout);
lock2.Remove();
// everything unlocked
}}
LOG_POST("\n--- Test 4");
// Reference count test
{{
assert( lock1.TryLock() );
assert( lock1.TryLock() );
assert( !lock2.TryLock() );
assert( lock1.TryLock() );
lock1.Unlock();
lock1.Unlock();
lock1.Unlock();
try {
lock1.Unlock();
assert(0);
}
catch (CInterProcessLockException&) {}
// everything unlocked
}}
// We don't need lock object anymore, remove it from the system
lock1.Remove();
}
