private void prepareMerger()
{
MergerMessage merMessage = m_mergerHandler.WaitForMessage(typeof(StartMergeMessage));//(StartMergeMessage));
m_log.Info("StartMergeMessage");
m_engine.Cleanup(); //make engine ready and set samples number to 0
m_maxThreadsCount = Environment.ProcessorCount * 2;
m_threadsCount = 0;
StartMergeMessage startMergeMes = merMessage as StartMergeMessage;
m_scene = new Utils.SceneBlobReferenceMessage(startMergeMes, false, startMergeMes.SceneId);
m_log.Info("Scene ID: " + startMergeMes.SceneId);
if (startMergeMes.RenderTime != 0)
{
m_totalRenderTime = startMergeMes.RenderTime * startMergeMes.RenderRoleCnt; //total time of rendering
m_oneBatchInPercents = (float)(startMergeMes.UpdateTime * 100.0) / (float)m_totalRenderTime; //one worker update in percents
}
if (startMergeMes.RequiredSpp != 0)
{
m_stopBySpp = true;
}
m_requiredSpp = startMergeMes.RequiredSpp;
m_log.Info("One worker update = " + m_oneBatchInPercents + "%");
m_percentageCompleted = 0; //rendered part of scene in percents
m_dispatcherHandler = new MessageQueue <DispetcherMessage>(startMergeMes.SceneId.ToString()); //create queue to dispatcher thread
m_dispatcherQueues.Add(startMergeMes.SceneId, m_dispatcherHandler);
m_instanceQueue = new MessageQueue <MergerMessage>(startMergeMes.SceneId.ToString(), true);
m_abortQueue = new MessageQueue <MergerMessage>(startMergeMes.SceneId.ToString() + "abort", true);
m_log.Info("sending 'I am ready' message");
m_dispatcherHandler.AddMessage(new MergerIsReady(startMergeMes.SessionId, startMergeMes.SceneId.ToString())); //signal to dispatcher: "Ready to work!"
m_isMerging = true;
m_log.Info("/StartMergeMessage");
}
private void processingScene(NetMessageHandler handler, SceneMessage message, byte[] sceneFile, string sessionGuid,
MessageQueue <DispetcherMessage> dispatcherHandler)
{
string sceneName = null;
int threadID = m_threadsID[sessionGuid];
string uniqueBlobName = string.Format("{0}_{1}", BlobName.UNIQUE_BLOB + threadID.ToString(), sessionGuid);
try
{
lock (m_BlobLock)
{
CloudBlockBlob blob = renderStorage.Get().CreateBlob(BlobName.SCENE_BLOB, uniqueBlobName);//sceneContainer.GetBlockBlobReference(uniqueBlobName);
Utils.UpploadBlobByteArray(blob, sceneFile);
sceneName = blob.Uri.ToString();
}
}
catch (Exception e)
{
m_log.Error("Error saving scene to blob: " + e.Message);
m_instanceManager.IncreaseFreeMergerCount(); //if no blob created than mark requested instances as free
//and kill thread
m_instanceManager.IncreaseFreeWorkerCount(message.InstanceCnt);
Thread.CurrentThread.Abort();
}
StartMergeMessage mergerMessage = new StartMergeMessage(message.InstanceCnt, message.TotalTime,
message.UpdateTime, sessionGuid, threadID, message.RequiredSpp);
m_mergerHandler.AddMessage(mergerMessage);
m_log.Info("IsMergerReady message sent");
WaitForWorkerAction action = new WaitForWorkerAction(sendClientMessage, handler);
lock (m_waitMergerLock)
{
//wait for merger allocating
InstanceManager.Get(m_log).WaitForMerger(dispatcherHandler, m_threadsID[sessionGuid], action);
}
lock (m_waitWorkerLock)
{
//check if workers has been already allocated, if no wait for it
InstanceManager.Get(m_log).WaitForWorkers(message.InstanceCnt, dispatcherHandler, sessionGuid, threadID, action);
}
sendClientMessage(handler, StatusMessage.StatusEnum.Allocated);
m_log.Info("StartMergeMessage sent to merger. ID: " + threadID);
m_log.Info("Scene GUID: " + sessionGuid + "Scene ID: " + threadID);
m_renderAbortHandlers.Add(threadID, new List <MessageQueue <RenderMessage> >()); //each m_renderAbortHandlers contains list of worker queues
MessageQueue <RenderMessage> toRenderQueue = new MessageQueue <RenderMessage>(threadID.ToString());
double sppPerOneWorker = 0; //how much spp is required from each worker
for (int i = 0; i < message.InstanceCnt; i++)
{
//adding new renderqueue for list that correspond to ID of scene which is connected with m_threadsID[sessionGuid]
try
{
MessageQueue <RenderMessage> newAbortQueue = new MessageQueue <RenderMessage>(threadID.ToString() + m_renderAbortHandlers[threadID].Count.ToString());
newAbortQueue.Clear();
m_renderAbortHandlers[threadID].Add(newAbortQueue);
}
catch (Exception e)
{
m_log.Error("Error creating queue: " + e.Message + ". ID: " + threadID);
}
sppPerOneWorker = message.RequiredSpp / message.InstanceCnt;
ToRenderMessage msg = new ToRenderMessage(sceneName, message.TotalTime,
message.UpdateTime, threadID, threadID.ToString() +
(m_renderAbortHandlers[threadID].Count - 1).ToString(), //scene ID + number of worker that is rendering this scene
sppPerOneWorker);
m_log.Info("Abort queue name suffix: " + (threadID.ToString() + (m_renderAbortHandlers[threadID].Count - 1)).ToString());
toRenderQueue.AddMessage(msg);
m_log.Info("ToRenderMessage sent to worker: " + i);
}
m_log.Info("ToRenderMessage sent to workers. ID: " + threadID);
}
public SceneBlobReferenceMessage(StartMergeMessage startMessage, bool sceneIsSet, int sceneID)
{
StartMessage = startMessage;
SceneID = sceneID;
}
