Texture *TextureManager::LoadTexture(WCHAR *filePath, bool async)
{
TextureUpload *newTextureUpload = new TextureUpload();
newTextureUpload->TextureToUpload = new Texture();
newTextureUpload->UploadState = TextureUploadState_Initialized;
newTextureUpload->FilePath = filePath;
newTextureUpload->ImageData = new DirectX::ScratchImage();
if(async)
{
std::lock_guard<std::mutex> lock(mTextureUploadMutex);
mTextureUploads.Add(newTextureUpload);
return newTextureUpload->TextureToUpload;
}
//synchronous uploads need to lock the upload context and stall for completion
Direct3DQueueManager *queueManager = mDirect3DManager->GetContextManager()->GetQueueManager();
UploadContext *uploadContext = mDirect3DManager->GetContextManager()->GetUploadContext();
ProcessFileRead(newTextureUpload);
uploadContext->LockUploads();
TextureBackgroundUpload uploadJob(mDirect3DManager->GetDevice(), queueManager, newTextureUpload);
uploadJob.ProcessUpload(uploadContext);
queueManager->GetCopyQueue()->WaitForFenceCPUBlocking(newTextureUpload->UploadFence);
uploadContext->UnlockUploads();
uint64 currentUploadFence = queueManager->GetCopyQueue()->PollCurrentFenceValue();
ProcessTransition(newTextureUpload, currentUploadFence);
newTextureUpload->TextureToUpload->SetIsReady(true);
Texture *newTexture = newTextureUpload->TextureToUpload;
delete newTextureUpload;
return newTexture;
}
// Called when the game starts or when spawned
void ACameraDirector::BeginPlay()
{
Super::BeginPlay();
//Set the target view of the player controller to the first camera in the array, if one exists.
if (ManagedCameras.Num() > 0)
{
ProcessTransition();
}
}
void TextureManager::ProcessCurrentUploads()
{
std::lock_guard<std::mutex> lock(mTextureUploadMutex);
Direct3DQueueManager *queueManager = mDirect3DManager->GetContextManager()->GetQueueManager();
uint64 currentUploadFence = queueManager->GetCopyQueue()->PollCurrentFenceValue();
uint32 numUploads = mTextureUploads.CurrentSize();
for (uint32 i = 0; i < numUploads; i++)
{
TextureUpload *currentUpload = mTextureUploads[i];
switch (currentUpload->UploadState)
{
case TextureUploadState_Initialized:
currentUpload->UploadState = TextureUploadState_Read;
break;
case TextureUploadState_Read:
currentUpload->UploadState = TextureUploadState_Pending;
currentUpload->ReadJob = new TextureReadJob(currentUpload, this);
ThreadPoolManager::GetSingleton()->GetBackgroundThreadPool()->AddSingleJob(currentUpload->ReadJob);
break;
case TextureUploadState_Upload:
currentUpload->UploadState = TextureUploadState_Pending;
mDirect3DManager->GetContextManager()->GetUploadContext()->AddBackgroundUpload(new TextureBackgroundUpload(mDirect3DManager->GetDevice(), queueManager, currentUpload));
break;
case TextureUploadState_Transition:
ProcessTransition(currentUpload, currentUploadFence);
break;
case TextureUploadState_Completed:
currentUpload->TextureToUpload->SetIsReady(true);
currentUpload->UploadState = TextureUploadState_Delete;
break;
case TextureUploadState_Pending:
//Background job is currently pending, just wait
break;
default:
Application::Assert(false);
break;
}
}
for (int32 i = 0; i < mTextureUploads.CurrentSizeSigned(); i++)
{
TextureUpload *currentUpload = mTextureUploads[i];
if (currentUpload->UploadState == TextureUploadState_Delete)
{
mTextureUploads.Remove(i);
delete currentUpload;
i--;
}
}
}
// Called every frame
void ACameraDirector::Tick( float DeltaTime )
{
Super::Tick( DeltaTime );
if (ManagedCameras.Num() > 0)
{
TimeToNextCameraChange -= DeltaTime;
if (TimeToNextCameraChange <= 0.f)
{
ProcessTransition();
}
}
}
// I tried to make this pretty closely match what is described in Godefroid and Cormac's POPL paper. I
// used the stack traversal optimizations and unlike what they describe in their paper I differentiated
// reads and writes. I'm very tentative about my use of happens-before here, and to some extent about
// the whole algorithm so it could use some double checking. -Katie
void Dpor::CompletedExecution(ChessExecution* exec, size_t depthBound) {
m_minStep = exec->NumTransitions();
m_svm = ChessImpl::GetSyncVarManager();
m_exec = exec;
m_enabled = static_cast<EnabledSet*>(exec->GetQueryEnabled());
m_backtrackingPoints.clear();
m_depthBound = depthBound;
m_bounded = ChessImpl::GetOptions().bounded;
const size_t numThreads = ChessImpl::NumThreads();
const size_t numTrans = exec->NumTransitions();
m_backtrackingPoints.resize(numTrans);
m_attributes.clear();
m_attributes.resize(numTrans);
m_lastNonPreemptionStep.clear();
const size_t oldBstep = exec->GetRecordIndex();
for (size_t i = 0; i < numTrans; i++) {
const ChessTransition trans = exec->Transition(i);
if (m_bounded) {
for (size_t tid = 1; tid < numThreads; tid++) {
if (trans.tid != tid && m_enabled->IsEnabledAtStep(i, tid) && !exec->RequiresPreemption(i, tid)) {
m_lastNonPreemptionStep[tid] = i;
}
}
}
// We don't need to bother actually searching for backtracking points until we get beyond this
// execution's backtracking point into its record mode transitions - the replay mode ones were
// already found during a previous execution.
if (i < oldBstep) {
PushTransition(i);
continue;
}
// handle choose operations that still have more choices
if (i < depthBound && trans.op == SVOP::CHOICE && trans.var > 0) {
AddBacktrackingPoint(i, trans.tid, false /* no matching acquire */);
}
// Iterate through every process in the system
for (size_t tid = 1; tid < numThreads; tid++) {
ChessTransition lookahead;
// Find the next task to be performed by tid.
if (!exec->GetLookaheadAtStep(i, tid, lookahead)) {
continue;
}
assert (lookahead.tid == tid);
ProcessTransition(i, lookahead);
}
PushTransition(i);
}
m_mostRecentWrite.clear();
m_mostRecentAccess.clear();
}