List<ShaderLibFile> CompileUnits(Spire::Compiler::CompileResult & compileResult,
ShaderCompiler * compiler, List<CompileUnit> & units,
Spire::Compiler::CompileOptions & options)
{
List<ShaderLibFile> resultFiles;
List<ImportOperatorHandler*> importHandlers;
List<ExportOperatorHandler*> exportHandlers;
CreateGLSLImportOperatorHandlers(importHandlers);
CreateGLSLExportOperatorHandlers(exportHandlers);
for (auto handler : exportHandlers)
compiler->RegisterExportOperator(L"glsl", handler);
for (auto handler : importHandlers)
compiler->RegisterImportOperator(L"glsl", handler);
try
{
if (compileResult.ErrorList.Count() == 0)
compiler->Compile(compileResult, units, options);
DestroyImportOperatorHanlders(importHandlers);
DestroyExportOperatorHanlders(exportHandlers);
}
catch (...)
{
DestroyImportOperatorHanlders(importHandlers);
DestroyExportOperatorHanlders(exportHandlers);
throw;
}
if (compileResult.Success)
{
if (options.Mode == CompilerMode::ProduceShader)
{
EnumerableDictionary<String, ShaderLibFile> shaderLibs;
for (auto file : compileResult.CompiledSource)
{
auto shaderName = Path::GetFileNameWithoutEXT(file.Key);
ShaderLibFile * libFile = shaderLibs.TryGetValue(shaderName);
if (!libFile)
{
shaderLibs.Add(shaderName, ShaderLibFile());
libFile = shaderLibs.TryGetValue(shaderName);
libFile->MetaData.ShaderName = shaderName;
}
libFile->Sources = file.Value;
}
for (auto & libFile : shaderLibs)
{
for (auto & shader : compileResult.Program->Shaders)
{
if (shader->MetaData.ShaderName == libFile.Key)
{
// fill in meta data
libFile.Value.MetaData = shader->MetaData;
}
}
resultFiles.Add(libFile.Value);
}
}
}
return resultFiles;
}
int ChoiceForm::AutotuneHelper(HashSet<String> & selectedChoices, EnumerableDictionary<String, Spire::Compiler::ShaderChoiceValue>& currentChoices, float timeBudget, bool countOnly)
{
auto choices = choiceControl->GetChoices(currentShaderName, currentChoices);
List<Spire::Compiler::ShaderChoice> filteredChoices;
for (auto & choice : choices)
if (!currentChoices.ContainsKey(choice.ChoiceName))
filteredChoices.Add(choice);
choices = _Move(filteredChoices);
// find first non-trivial choice
Spire::Compiler::ShaderChoice * currentChoice = nullptr;
for (auto & choice : choices)
{
if (choice.Options.Count() > 1 && selectedChoices.Contains(choice.ChoiceName))
{
currentChoice = &choice;
break;
}
}
if (currentChoice)
{
int count = 0;
for (auto & opt : currentChoice->Options)
{
EnumerableDictionary<String, Spire::Compiler::ShaderChoiceValue> newChoices = currentChoices;
newChoices[currentChoice->ChoiceName] = opt;
count += AutotuneHelper(selectedChoices, newChoices, timeBudget, countOnly);
}
return count;
}
else
{
if (!countOnly)
{
printf("Testing shader variant...");
// compile and evaluate
auto schedule = GenerateSchedule(currentChoices, EnumerableDictionary<String, EnumerableDictionary<String, String>>());
choiceControl->RecompileShader(currentShaderName, schedule);
// render 1000 frames and measure time
float minTime = 1e30f;
for (int f = 0; f < 20; f++)
{
glFinish();
auto timeP = CoreLib::Diagnostics::PerformanceCounter::Start();
for (int i = 0; i < 10; i++)
{
choiceControl->RenderFrame();
}
glFinish();
auto time = (float)CoreLib::Diagnostics::PerformanceCounter::ToSeconds(CoreLib::Diagnostics::PerformanceCounter::End(timeP)) * 100.0f;
if (time < minTime)
minTime = time;
}
choiceControl->UpdateWindow();
auto frameData = ReadFrameData(choiceControl->RenderFrame());
float error = MeasureError(referenceFrame, frameData);
float value = 0;
if (minTime < timeBudget)
value = error;
else
value = 20.0f + minTime;
if (value < currentBestValue)
{
currentBestValue = value;
currentBestChoices = currentChoices;
}
autotuningLog << minTime << L"," << error<<EndLine;
printf("%f ms, error: %f\n", minTime, error);
}
return 1;
}
}
/* Generate a shader variant by applying mechanic choice rules and the choice file.
The choice file provides "preferred" definitions, as represented in ShaderComponentSymbol::Type::PinnedWorlds
The process resolves the component references by picking a pinned definition if one is available, or a definition
with the preferred import path as defined by import operator ordering.
After all references are resolved, all unreferenced definitions (dead code) are eliminated,
resulting a shader variant ready for code generation.
*/
RefPtr<ShaderIR> GenerateShaderVariantIR(CompileResult & cresult, ShaderClosure * shader, Schedule & schedule, SymbolTable * symbolTable)
{
RefPtr<ShaderIR> result = new ShaderIR();
result->Shader = shader;
result->SymbolTable = symbolTable;
// mark pinned worlds
for (auto & comp : shader->Components)
{
for (auto & impl : comp.Value->Implementations)
{
for (auto & w : impl->Worlds)
{
if (impl->SrcPinnedWorlds.Contains(w) || impl->SyntaxNode->IsInline() || impl->ExportWorlds.Contains(w) || impl->SyntaxNode->IsInput())
{
comp.Value->Type->PinnedWorlds.Add(w);
}
}
}
}
// apply choices
Dictionary<String, ShaderComponentSymbol*> choiceComps;
for (auto & comp : shader->AllComponents)
{
for (auto & choiceName : comp.Value.Symbol->ChoiceNames)
choiceComps[choiceName] = comp.Value.Symbol;
}
HashSet<ShaderComponentImplSymbol*> pinnedImpl;
for (auto & choice : schedule.Choices)
{
ShaderComponentSymbol * comp = nullptr;
if (choiceComps.TryGetValue(choice.Key, comp))
{
comp->Type->PinnedWorlds.Clear();
for (auto & selectedDef : choice.Value)
{
if (comp->Type->ConstrainedWorlds.Contains(selectedDef->WorldName))
{
comp->Type->PinnedWorlds.Add(selectedDef->WorldName);
// find specified impl
for (auto & impl : comp->Implementations)
{
if (impl->Worlds.Contains(selectedDef->WorldName))
pinnedImpl.Add(impl.Ptr());
}
}
else
{
cresult.GetErrorWriter()->diagnose(selectedDef.Ptr()->Position, Diagnostics::worldIsNotAValidChoiceForKey, selectedDef->WorldName, choice.Key);
}
}
}
}
for (auto & attribs : schedule.AddtionalAttributes)
{
ShaderComponentSymbol * comp = nullptr;
if (choiceComps.TryGetValue(attribs.Key, comp))
{
// apply attributes
for (auto & impl : comp->Implementations)
{
for (auto & attrib : attribs.Value)
{
auto modifier = new SimpleAttribute();
modifier->Key = attrib.Key;
modifier->Value.Content = attrib.Value;
modifier->next = impl->SyntaxNode->modifiers.first;
impl->SyntaxNode->modifiers.first = modifier;
}
}
}
}
// generate definitions
Dictionary<ShaderClosure*, ModuleInstanceIR*> moduleInstanceMap;
auto createModuleInstance = [&](ShaderClosure * closure)
{
ModuleInstanceIR * inst;
if (moduleInstanceMap.TryGetValue(closure, inst))
return inst;
List<String> namePath;
auto parent = closure;
while (parent)
{
if (parent->Name.Length())
namePath.Add(parent->Name);
else
namePath.Add(parent->ModuleSyntaxNode->Name.Content);
parent = parent->Parent;
}
StringBuilder sbBindingName;
for (int i = namePath.Count() - 2; i >= 0; i--)
{
sbBindingName << namePath[i];
if (i > 0)
sbBindingName << ".";
}
// if this is the root module, its binding name is module name.
if (namePath.Count() == 1)
sbBindingName << namePath[0];
inst = new ModuleInstanceIR();
inst->SyntaxNode = closure->ModuleSyntaxNode;
inst->BindingIndex = closure->BindingIndex;
inst->UsingPosition = closure->UsingPosition;
result->ModuleInstances.Add(inst);
inst->BindingName = sbBindingName.ProduceString();
moduleInstanceMap[closure] = inst;
return inst;
};
for (auto & comp : shader->AllComponents)
{
EnumerableDictionary<String, ComponentDefinitionIR*> defs;
Dictionary<String, ShaderComponentImplSymbol*> impls;
for (auto & impl : comp.Value.Symbol->Implementations)
{
auto createComponentDef = [&](const String & w)
{
RefPtr<ComponentDefinitionIR> def = new ComponentDefinitionIR();
def->OriginalName = comp.Value.Symbol->Name;
def->UniqueKey = comp.Value.Symbol->UniqueKey;
def->UniqueName = comp.Value.Symbol->UniqueName;
def->Type = comp.Value.Symbol->Type->DataType;
def->IsEntryPoint = (impl->ExportWorlds.Contains(w) || impl->SyntaxNode->IsParam() ||
(shader->Pipeline->IsAbstractWorld(w) &&
(impl->SyntaxNode->HasSimpleAttribute("Pinned") || shader->Pipeline->Worlds[w]()->HasSimpleAttribute("Pinned"))));
CloneContext cloneCtx;
def->SyntaxNode = impl->SyntaxNode->Clone(cloneCtx);
def->World = w;
def->ModuleInstance = createModuleInstance(comp.Value.Closure);
return def;
};
// parameter component will only have one defintion that is shared by all worlds
if (impl->SyntaxNode->IsParam())
{
auto def = createComponentDef("<uniform>");
result->Definitions.Add(def);
defs["<uniform>"] = def.Ptr();
}
else
{
for (auto & w : impl->Worlds)
{
auto def = createComponentDef(w);
result->Definitions.Add(def);
bool existingDefIsPinned = false;
if (defs.ContainsKey(w))
existingDefIsPinned = pinnedImpl.Contains(impls[w]());
if (!existingDefIsPinned)
{
defs[w] = def.Ptr();
impls[w] = impl.Ptr();
}
}
}
}
result->DefinitionsByComponent[comp.Key] = defs;
}
bool changed = true;
while (changed)
{
changed = false;
result->ResolveComponentReference();
result->EliminateDeadCode();
// check circular references
for (auto & def : result->Definitions)
{
if (def->Dependency.Contains(def.Ptr()))
{
cresult.GetErrorWriter()->diagnose(def->SyntaxNode->Position, Diagnostics::componentDefinitionCircularity, def->OriginalName);
return nullptr;
}
}
/*
// eliminate redundant (downstream) definitions, one at a time
auto comps = result->GetComponentDependencyOrder();
for (int i = comps.Count() - 1; i >= 0; i--)
{
auto comp = comps[i];
auto & defs = result->DefinitionsByComponent[comp->UniqueName]();
EnumerableHashSet<ComponentDefinitionIR*> removedDefs;
for (auto & def : defs)
if (!def.Value->IsEntryPoint && !comp->Type->PinnedWorlds.Contains(def.Value->World))
{
for (auto & otherDef : defs)
{
if (otherDef.Value != def.Value && !removedDefs.Contains(otherDef.Value)
&& shader->Pipeline->IsWorldReachable(otherDef.Value->World, def.Value->World))
{
removedDefs.Add(def.Value);
break;
}
}
}
if (removedDefs.Count())
{
result->RemoveDefinitions([&](ComponentDefinitionIR* def) {return removedDefs.Contains(def); });
changed = true;
}
}
*/
}
return result;
}
