void HashGrid::AddFlux(const Point &hitPoint, const Vector &wi,
const Spectrum &photonFlux) {
// Look for eye path hit points near the current hit point
Vector hh = (hitPoint - hitPoints->GetBBox().pMin) * invCellSize;
const int ix = abs(int(hh.x));
const int iy = abs(int(hh.y));
const int iz = abs(int(hh.z));
std::list<HitPoint *> *hps = grid[Hash(ix, iy, iz)];
if (hps) {
std::list<HitPoint *>::iterator iter = hps->begin();
while (iter != hps->end()) {
HitPoint *hp = *iter++;
const float dist2 = DistanceSquared(hp->position, hitPoint);
if ((dist2 > hp->accumPhotonRadius2))
continue;
const float dot = Dot(hp->normal, wi);
if (dot <= 0.0001f)
continue;
AtomicInc(&hp->accumPhotonCount);
Spectrum flux = photonFlux * hp->material->f(hp->wo, wi, hp->normal) * hp->throughput;
AtomicAdd(&hp->accumReflectedFlux.r, flux.r);
AtomicAdd(&hp->accumReflectedFlux.g, flux.g);
AtomicAdd(&hp->accumReflectedFlux.b, flux.b);
}
}
}
bool Thread::Run(Callback _cb)
{
LLOG("Thread::Run");
AtomicInc(sThreadCount);
if(!threadr)
#ifndef CPU_BLACKFIN
threadr = sMain = true;
#else
{
threadr = true;
//the sMain replacement
#ifdef PLATFORM_POSIX
pthread_t thid = pthread_self();
vm.Enter();
if(threadsv.Find(thid) < 0){
//thread not yet present, mark present
threadsv.Add(thid);
}
else
RLOG("BUG: Multiple Add in Mt.cpp");
vm.Leave();
#endif
}
#endif
Detach();
Callback *cb = new Callback(_cb);
#ifdef PLATFORM_WIN32
handle = (HANDLE)_beginthreadex(0, 0, sThreadRoutine, cb, 0, ((unsigned int *)(&thread_id)));
#endif
#ifdef PLATFORM_POSIX
if(pthread_create(&handle, 0, sThreadRoutine, cb))
handle = 0;
#endif
return handle;
}
void ImageMT::Square()
{
if(m_pLayers.GetCount()<=0)
return;
Layer* pLayer = m_pLayers[0];
double f = m_fPower.GetData();
AtomicInc(threads);
Thread().Run(callback4(&Layer::MakeLayerAsThread,pLayer,f,this,0));
}
TimerTest::TimerTest()
: demo(0)
{
CtrlLayout(*this, "Window title");
int a = AtomicInc(demo);
ASSERT(a==1); //preload, 1 means running demo mode, 2 means a cb is executing
#ifdef REPEAT_TEST
t.SetTimeCallback(-TIMEOUT, THISBACK(Test), (intptr_t)this);
#else
t.SetTimeCallback(0, THISBACK(Test), (intptr_t)this);
#endif
}
void String::LSet(const String& s)
{
ptr = s.ptr;
w[2] = s.w[2];
w[3] = s.w[3];
if(s.IsRef()) {
if(ptr != VoidPtr())
AtomicInc(s.Ref()->refcount);
}
else {
ptr = (char *)MAlloc_S();
qptr[0] = s.qptr[0];
qptr[1] = s.qptr[1];
qptr[2] = s.qptr[2];
qptr[3] = s.qptr[3];
}
}
void String0::LSet(const String0& s)
{
w[2] = s.w[2];
w[3] = s.w[3];
if(s.IsRef()) {
ptr = s.ptr;
if(ptr != (char *)(voidptr + 1))
AtomicInc(s.Ref()->refcount);
}
else {
ptr = (char *)MAlloc_S();
qptr[0] = s.qptr[0];
qptr[1] = s.qptr[1];
qptr[2] = s.qptr[2];
qptr[3] = s.qptr[3];
}
}
void TimerTest::Test()
{
int a = AtomicInc(demo);
ASSERT(a==2);
Info("O");
RLOG("O");
a = AtomicDec(demo);
if(a<=0)
return;
ASSERT(a>=0);
#ifdef REPEAT_TEST
#else
t.SetTimeCallback(TIMEOUT, THISBACK(Test), (int)this);
#endif
}
void
LogIt(char *Format, UINT_PTR Info0, UINT_PTR Info1)
{
TIMESTAMP Now = CurrentTime();
INT i;
BOOL Wrapped = 0;
for (;;) {
/* Disabled ?
*/
if (LogP == NOLOG)
return;
/* Get a number, make sure its good.
*/
Retry:
i = AtomicInc(&LogP) - 1;
if (i >= LOGSIZE) {
/* Roundabout, with care
*/
Wrapped = TRUE;
if (!AtomicCmpAndSwap(&LogP,
i+1,
0))
goto Retry;
} else
/* Good one.
*/
break;
}
LogBuf[i].Format = Format;
LogBuf[i].When = Now;
LogBuf[i].Info[0] = Info0;
LogBuf[i].Info[1] = Info1;
#if 0
printf("LOG '%s' %08x %08x " TIMESTAMP_FORMAT_STRING "\n",
LogBuf[i].Format,
LogBuf[i].Info[0],
LogBuf[i].Info[1],
LogBuf[i].When);
#endif
if (Wrapped)
PrintZeLog();
}
void Threads::Process(const FractalJobHandeler & job)
{
ProgressInfo statTotal(statusBar);
rows = inp_row.GetData();
cols = inp_col.GetData();
densityR = picbox.GetSize().cy / rows;
densityC = picbox.GetSize().cx / cols;
maxIter = inp_iter.GetData();
logmax= log10((double)maxIter);
max_threads = inp_threads.GetData();
statTotal.Set(0,rows*cols);
TimeStop startTime;
for (int r = 0; r < rows; r++){
for (int c = 0; c < cols; c++)
{
while(threads >= max_threads)
waitforfinish.Wait();
AtomicInc(threads);
Thread().Run(callback4(this, &Threads::ThreadRenderJob, r, c, job, 0));
INTERLOCKED_(job_lock)
active.Add((r * cols + c), 0);
statTotal.Text(Format("Invoking calculations for sector R:%02d C:%02d",r,c));
time.Set(FormatTS(startTime.Elapsed()));
picbox.Refresh();
statTotal.Set(r * cols + c,rows*cols);
ProcessEvents();
}
}
while(threads > 0)
waitforfinish.Wait();
time.Set(FormatTS(startTime.Elapsed()));
picbox.Refresh();
}
void _NGM::AddReadRead(int readid) {
AtomicInc(&m_ReadReads);
}
void _NGM::AddWrittenRead(int readid) {
AtomicInc(&m_WrittenReads);
}
void _NGM::AddMappedRead(int readid) {
AtomicInc(&m_MappedReads);
}
void LWorker::Sleep()
{
AtomicInc( &m_Scheduler.m_cSleepingWorkers );
m_Scheduler.m_WakeSemaphore.Wait();
AtomicDec( &m_Scheduler.m_cSleepingWorkers );
}
void ConnectorInterface::Close()
{
AtomicInc(m_terminating);
AtomicDec(m_isConnectedFinished);
AtomicInc(m_isDisconnected);
if (s_tracerThread)
{
if (!thread::IsThreadTerminated(s_tracerThread))
{
while (IsConnected() && !thread::IsThreadTerminated(s_tracerThread))
{
behaviac::Thread::Sleep(1);
}
}
{
ScopedLock lock(m_packetBuffersLock);
for (int i = 0; i < this->m_maxTracedThreads; ++i)
{
BEHAVIAC_DELETE(m_packetBuffers[i]);
}
BEHAVIAC_G_DELETE_ARRAY(m_packetBuffers);
m_packetBuffers = 0;
}
if (!thread::IsThreadTerminated(s_tracerThread))
{
thread::StopThread(s_tracerThread);
}
s_tracerThread = 0;
}
if (m_packetCollection)
{
m_packetCollection->Close();
BEHAVIAC_DELETE(m_packetCollection);
m_packetCollection = 0;
}
BEHAVIAC_DELETE(m_packetPool);
m_packetPool = 0;
#if BEHAVIAC_COMPILER_MSVC
if (t_packetBufferIndex != TLS_OUT_OF_INDEXES)
{
TlsFree(t_packetBufferIndex);
t_packetBufferIndex = TLS_OUT_OF_INDEXES;
}
#else
t_packetBufferIndex = 0;
#endif
behaviac::Socket::ShutdownSockets();
AtomicDec(m_isInited);
}
void Thread::BeginShutdownThreads()
{
AtomicInc(sShutdown);
}
RpcGet RpcRequest::Execute()
{
if(!shouldExecute)
return RpcGet();
shouldExecute = false;
String request;
if(json) {
ContentType("application/json");
static Atomic id;
Json json;
json("jsonrpc", "2.0")
("method", method);
if(data.out.GetCount()) {
JsonArray a;
for(int i = 0; i < data.out.GetCount(); i++) {
const Value& v = data.out[i];
if(v.Is<RawJsonText>())
a.CatRaw(v.To<RawJsonText>().json);
else
a << JsonRpcData(v);
}
json("params", a);
}
else
if(data.out_map.GetCount()) {
Json m;
for(int i = 0; i < data.out_map.GetCount(); i++) {
const Value& v = data.out_map.GetValue(i);
String key = (String)data.out_map.GetKey(i);
if(v.Is<RawJsonText>())
m.CatRaw(key, v.To<RawJsonText>().json);
else
m(key, JsonRpcData(v));
}
json("params", m);
}
json("id", id);
AtomicInc(id);
request = ~json;
}
else {
ContentType("text/xml");
request = XmlHeader();
request << XmlTag("methodCall")(XmlTag("methodName")(method) + FormatXmlRpcParams(data.out));
}
if(sLogRpcCalls) {
if(sLogRpcCallsCompress)
RLOG("=== XmlRpc call request:\n" << CompressLog(request));
else
RLOG("=== XmlRpc call request:\n" << request);
}
String response;
New();
if(shorted)
response = RpcExecuteShorted(request);
else
response = Post(request).Execute();
if(sLogRpcCalls) {
if(sLogRpcCallsCompress)
RLOG("=== XmlRpc call response:\n" << CompressLog(response));
else
RLOG("=== XmlRpc call response:\n" << response);
}
RpcGet h;
if(IsNull(response)) {
faultCode = RPC_CLIENT_HTTP_ERROR;
faultString = GetErrorDesc();
error = "Http request failed: " + faultString;
LLOG(error);
h.v = ErrorValue(error);
return h;
}
if(json) {
try {
Value r = ParseJSON(response);
if(IsValueMap(r)) {
ValueMap m = r;
Value result = m["result"];
if(!result.IsVoid()) {
data.in.Clear();
data.in.Add(result);
data.ii = 0;
h.v = result;
return h;
}
Value e = m["error"];
if(IsValueMap(e)) {
Value c = e["code"];
Value m = e["message"];
if(IsNumber(c) && IsString(m)) {
faultCode = e["code"];
faultString = e["message"];
error.Clear();
error << "Failed '" << faultString << "' (" << faultCode << ')';
LLOG(s);
h.v = ErrorValue(error);
return h;
}
}
}
String s;
faultString = "Invalid response";
faultCode = RPC_CLIENT_RESPONSE_ERROR;
error = faultString;
LLOG(error);
h.v = ErrorValue(error);
return h;
}
catch(CParser::Error e) {
String s;
faultString = e;
faultCode = RPC_CLIENT_JSON_ERROR;
error.Clear();
error << "JSON Error: " << faultString;
LLOG(error);
h.v = ErrorValue(error);
return h;
}
}
else {
XmlParser p(response);
try {
p.ReadPI();
p.PassTag("methodResponse");
if(p.Tag("fault")) {
Value m = ParseXmlRpcValue(p);
if(IsValueMap(m)) {
ValueMap mm = m;
faultString = mm["faultString"];
faultCode = mm["faultCode"];
error.Clear();
error << "Failed '" << faultString << "' (" << faultCode << ')';
LLOG(s);
h.v = ErrorValue(error);
return h;
}
}
else {
data.in = ParseXmlRpcParams(p);
data.ii = 0;
p.PassEnd();
}
}
catch(XmlError e) {
String s;
faultString = e;
faultCode = RPC_CLIENT_XML_ERROR;
error.Clear();
error << "XML Error: " << faultString;
LLOG(error << ": " << p.GetPtr());
h.v = ErrorValue(error);
return h;
}
h.v = data.in.GetCount() ? data.in[0] : Null;
return h;
}
}
bool LWorker::ExecuteUntilNoWork()
{
#if AX_PROFILING_ENABLED
CProfileSampler Sampler;
#endif
CAutoNotifyExecuteUntilNoWork Notification_ExecuteUntilNoWork_;
#if !AX_ASYNC_PER_CHAIN_INDEX_ENABLED
const uint32 stride = m_Scheduler.m_cWorkers;
const uint32 base = m_uWorkerId;
//const uint32 originalChainIndex = m_uChainIndex;
//const uint32 originalLocalIndex = m_uLocalIndex;
#endif
const bool bDoWork = m_uChainIndex < m_Scheduler.m_cSubmittedChains;
#if AX_PROFILING_ENABLED
if( bDoWork ) {
Sampler.Enter( "ExecuteUntilNoWork - %s", g_pszWorkerNames[ m_uWorkerId ] );
}
#endif
#if AX_ASYNC_PER_WORKER_IDLE_FLAG_ENABLED
m_bIsWorking = true;
AX_MEMORY_BARRIER();
#else
m_Scheduler.DecIdleWorker();
#endif
CNotifyFetchJob Notify_FetchJob_;
CNotifyExecuteJob Notify_ExecJob_;
CNotifyUpdateExecStats Notify_UpdateStats_;
CNotifyDispatchDeferredWork Notify_LazyDispatch_;
CNotifyUpdateJobChain Notify_UpdateChain_;
while( m_uChainIndex < m_Scheduler.m_cSubmittedChains ) {
SJobChain *const pChain = m_Scheduler.m_pSubmittedChains[ m_uChainIndex ];
m_ExecutionState.LazyUpdate.uLastJobChain = m_uChainIndex;
m_ExecutionState.LazyUpdate.LastJobChainMinJobCPUTime = uint64( -1 );
m_ExecutionState.LazyUpdate.LastJobChainMaxJobCPUTime = 0;
m_ExecutionState.LazyUpdate.LastJobChainTotalCPUTime = 0;
AX_MEMORY_BARRIER();
for(;;) {
Notify_FetchJob_.Enter();
#if AX_ASYNC_PER_CHAIN_INDEX_ENABLED
const uint32 index = AtomicInc( &pChain->uReadIndex );
#else
const uint32 index = base + m_uLocalIndex*stride;
#endif
Notify_FetchJob_.Leave();
if( index >= pChain->cJobs ) {
NotifyJobNotFetched();
break;
}
NotifyJobFetched();
Notify_ExecJob_.Enter();
const uint64 jobCPUTime = pChain->pJobs[ index ].Execute( m_ExecutionState );
Notify_ExecJob_.Leave();
#if !AX_ASYNC_PER_CHAIN_INDEX_ENABLED
++m_uLocalIndex;
#endif
#if AX_PROFILING_ENABLED
Notify_UpdateStats_.Enter();
m_ExecutionState.LazyUpdate.AddJobCPUTime( jobCPUTime );
Notify_UpdateStats_.Leave();
#else
( void )jobCPUTime;
#endif
}
++m_uChainIndex;
#if !AX_ASYNC_PER_CHAIN_INDEX_ENABLED
m_uLocalIndex = 0;
#endif
Notify_LazyDispatch_.Enter();
m_ExecutionState.LazyUpdate.CommitDispatch();
Notify_LazyDispatch_.Leave();
Notify_UpdateChain_.Enter();
m_ExecutionState.LazyUpdate.CommitLastJobChain();
Notify_UpdateChain_.Leave();
}
#if AX_ASYNC_PER_WORKER_IDLE_FLAG_ENABLED
m_bIsWorking = false;
AX_MEMORY_BARRIER();
#else
m_Scheduler.IncIdleWorker();
#endif
//return originalChainIndex != m_uChainIndex || originalLocalIndex != m_uLocalIndex;
return bDoWork;
}
void ConnectorInterface::ThreadFunc()
{
#if BEHAVIAC_COMPILER_MSVC
//printf("ThreadFunc gs_threadFlag = %d\n", (int)gs_threadFlag.value());
BEHAVIAC_ASSERT(gs_threadFlag.value() == 0);
#endif
{
ScopedInt_t scopedInt(&gs_threadFlag);
Log("behaviac: Socket Thread Starting\n");
#if BEHAVIAC_COMPILER_MSVC
BEHAVIAC_ASSERT(t_packetBufferIndex != TLS_OUT_OF_INDEXES);
#else
//printf("ThreadFunc t_packetBufferIndex = %d\n", t_packetBufferIndex);
//BEHAVIAC_ASSERT(t_packetBufferIndex != (unsigned int)-1);
#endif//
}
namespace Socket = behaviac::Socket;
const bool blockingSocket = true;
behaviac::Socket::Handle serverSocket = 0;
{
ScopedInt_t scopedInt(&gs_threadFlag);
serverSocket = Socket::Create(blockingSocket);
if (!serverSocket)
{
Log("behaviac: Couldn't create server socket.\n");
return;
}
char bufferTemp[64];
string_sprintf(bufferTemp, "behaviac: Listening at port %d...\n", m_port);
Log(bufferTemp);
// max connections: 1, don't allow multiple clients?
if (!Socket::Listen(serverSocket, m_port, 1))
{
Log("behaviac: Couldn't configure server socket.\n");
Socket::Close(serverSocket);
return;
}
}
#if BEHAVIAC_COMPILER_MSVC
BEHAVIAC_ASSERT(gs_threadFlag.value() == 0);
#endif
this->ReserveThreadPacketBuffer();
while (!m_terminating)
{
#if BEHAVIAC_COMPILER_MSVC
//wait for connecting
while (!m_terminating)
{
//Log("Socket::TestConnection.\n");
if (Socket::TestConnection(serverSocket))
{
break;
}
behaviac::Thread::Sleep(100);
}
#endif
if (!m_terminating)
{
BEHAVIAC_ASSERT(gs_threadFlag.value() == 0);
Log("behaviac: accepting...\n");
{
ScopedInt_t scopedInt(&gs_threadFlag);
m_writeSocket = Socket::Accept(serverSocket, kSocketBufferSize);
if (!m_writeSocket)
{
Log("behaviac: Couldn't create write socket.\n");
Socket::Close(serverSocket);
return;
}
Log("behaviac: connection accepted\n");
}
BEHAVIAC_ASSERT(gs_threadFlag.value() == 0);
{
ScopedInt_t scopedInt(&gs_threadFlag);
AtomicInc(m_isConnected);
behaviac::Thread::Sleep(1);
OnConnection();
AtomicInc(m_isConnectedFinished);
behaviac::Thread::Sleep(1);
//this->OnConnectionFinished();
Log("behaviac: after Connected.\n");
}
BEHAVIAC_ASSERT(gs_threadFlag.value() == 0);
while (!m_terminating && this->m_writeSocket)
{
behaviac::Thread::Sleep(1);
SendAllPackets();
ReceivePackets();
}
BEHAVIAC_ASSERT(gs_threadFlag.value() == 0);
// One last time, to send any outstanding packets out there.
if (this->m_writeSocket)
{
SendAllPackets();
Socket::Close(m_writeSocket);
}
this->Clear();
Log("behaviac: disconnected. \n");
}
}//while (!m_terminating)
Socket::Close(serverSocket);
this->Clear();
BEHAVIAC_ASSERT(gs_threadFlag.value() == 0);
Log("behaviac: ThreadFunc exited. \n");
}
void MScheduler::IncIdleWorker()
{
AtomicInc( &m_cIdleWorkers );
}
void _NGM::AddUnmappedRead(MappedRead const * const read, int reason) {
AtomicInc(&m_UnmappedReads);
Log.Debug(LOG_OUTPUT_DETAILS, "Read %s (%i) not mapped (%i)", read->name, read->ReadId, reason);
}
