blob: d2a2feeb9203641a74f46efb0a9b6bd4a875291f [file] [log] [blame] [edit]
/*-------------------------------------------------------------------------
* drawElements Quality Program Random Shader Generator
* ----------------------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief Variable manager.
*//*--------------------------------------------------------------------*/
#include "rsgVariableManager.hpp"
#include <algorithm>
#include <map>
#include <set>
using std::vector;
using std::set;
using std::map;
namespace rsg
{
class SubValueRangeIterator
{
public:
SubValueRangeIterator (const ConstValueRangeAccess& valueRange);
~SubValueRangeIterator (void) {}
bool hasItem (void) const;
ConstValueRangeAccess getItem (void) const;
void next (void);
private:
vector<ConstValueRangeAccess> m_stack;
};
SubValueRangeIterator::SubValueRangeIterator (const ConstValueRangeAccess& valueRange)
{
m_stack.push_back(valueRange);
}
inline bool SubValueRangeIterator::hasItem (void) const
{
return !m_stack.empty();
}
inline ConstValueRangeAccess SubValueRangeIterator::getItem (void) const
{
return m_stack[m_stack.size()-1];
}
void SubValueRangeIterator::next (void)
{
ConstValueRangeAccess curItem = getItem();
m_stack.pop_back(); // Remove current
switch (curItem.getType().getBaseType())
{
case VariableType::TYPE_ARRAY:
{
int numElements = curItem.getType().getNumElements();
for (int ndx = 0; ndx < numElements; ndx++)
m_stack.push_back(curItem.member(ndx));
break;
}
case VariableType::TYPE_STRUCT:
{
int numMembers = (int)curItem.getType().getMembers().size();
for (int ndx = 0; ndx < numMembers; ndx++)
m_stack.push_back(curItem.member(ndx));
break;
}
default:
break; // \todo [2011-02-03 pyry] Swizzle control?
}
}
ValueEntry::ValueEntry (const Variable* variable)
: m_variable (variable)
, m_valueRange (variable->getType())
{
}
VariableScope::VariableScope (void)
{
}
VariableScope::~VariableScope (void)
{
for (vector<Variable*>::iterator i = m_declaredVariables.begin(); i != m_declaredVariables.end(); i++)
delete *i;
for (vector<Variable*>::iterator i = m_liveVariables.begin(); i != m_liveVariables.end(); i++)
delete *i;
}
Variable* VariableScope::allocate (const VariableType& type, Variable::Storage storage, const char* name)
{
Variable* variable = new Variable(type, storage, name);
try
{
m_liveVariables.push_back(variable);
return variable;
}
catch (const std::exception&)
{
delete variable;
throw;
}
}
void VariableScope::declare (Variable* variable)
{
m_declaredVariables.push_back(variable);
removeLive(variable);
}
void VariableScope::removeLive (const Variable* variable)
{
vector<Variable*>::iterator pos = std::find(m_liveVariables.begin(), m_liveVariables.end(), variable);
DE_ASSERT(pos != m_liveVariables.end());
// \todo [pyry] Not so efficient
m_liveVariables.erase(pos);
}
ValueScope::ValueScope (void)
{
}
ValueScope::~ValueScope (void)
{
clear();
}
void ValueScope::clear (void)
{
for (vector<ValueEntry*>::iterator i = m_entries.begin(); i != m_entries.end(); i++)
delete *i;
m_entries.clear();
}
ValueEntry* ValueScope::allocate (const Variable* variable)
{
ValueEntry* entry = new ValueEntry(variable);
try
{
m_entries.push_back(entry);
return entry;
}
catch (const std::exception&)
{
delete entry;
throw;
}
}
class CompareEntryVariable
{
public:
CompareEntryVariable (const Variable* variable)
: m_variable(variable)
{
}
bool operator== (const ValueEntry* entry) const
{
return entry->getVariable() == m_variable;
}
private:
const Variable* m_variable;
};
bool operator== (const ValueEntry* entry, const CompareEntryVariable& cmp)
{
return cmp == entry;
}
ValueEntry* ValueScope::findEntry (const Variable* variable) const
{
vector<ValueEntry*>::const_iterator pos = std::find(m_entries.begin(), m_entries.end(), CompareEntryVariable(variable));
return pos != m_entries.end() ? *pos : DE_NULL;
}
void ValueScope::setValue (const Variable* variable, ConstValueRangeAccess value)
{
ValueEntry* entry = findEntry(variable);
DE_ASSERT(entry);
ValueRangeAccess dst = entry->getValueRange();
dst.getMin() = value.getMin().value();
dst.getMax() = value.getMax().value();
}
void ValueScope::removeValue (const Variable* variable)
{
vector<ValueEntry*>::iterator pos = std::find(m_entries.begin(), m_entries.end(), CompareEntryVariable(variable));
if (pos != m_entries.end())
{
ValueEntry* entry = *pos;
m_entries.erase(pos);
delete entry;
}
}
VariableManager::VariableManager (NameAllocator& nameAllocator)
: m_numAllocatedScalars (0)
, m_numAllocatedShaderInScalars (0)
, m_numAllocatedShaderInVariables (0)
, m_numAllocatedUniformScalars (0)
, m_nameAllocator (nameAllocator)
{
}
VariableManager::~VariableManager (void)
{
}
Variable* VariableManager::allocate (const VariableType& type)
{
return allocate(type, Variable::STORAGE_LOCAL, m_nameAllocator.allocate().c_str());
}
Variable* VariableManager::allocate (const VariableType& type, Variable::Storage storage, const char* name)
{
VariableScope& varScope = getCurVariableScope();
ValueScope& valueScope = getCurValueScope();
int numScalars = type.getScalarSize();
// Allocate in current scope
Variable* variable = varScope.allocate(type, Variable::STORAGE_LOCAL, name);
// Allocate value entry
ValueEntry* valueEntry = valueScope.allocate(variable);
// Add to cache
m_entryCache.push_back(valueEntry);
m_numAllocatedScalars += numScalars;
// Set actual storage - affects uniform/shader in allocations.
setStorage(variable, storage);
return variable;
}
void VariableManager::setStorage (Variable* variable, Variable::Storage storage)
{
int numScalars = variable->getType().getScalarSize();
// Decrement old.
if (variable->getStorage() == Variable::STORAGE_SHADER_IN)
{
m_numAllocatedShaderInScalars -= numScalars;
m_numAllocatedShaderInVariables -= 1;
}
else if (variable->getStorage() == Variable::STORAGE_UNIFORM)
m_numAllocatedUniformScalars -= numScalars;
// Add new.
if (storage == Variable::STORAGE_SHADER_IN)
{
m_numAllocatedShaderInScalars += numScalars;
m_numAllocatedShaderInVariables += 1;
}
else if (storage == Variable::STORAGE_UNIFORM)
m_numAllocatedUniformScalars += numScalars;
variable->setStorage(storage);
}
bool VariableManager::canDeclareInCurrentScope (const Variable* variable) const
{
const vector<Variable*>& curLiveVars = getCurVariableScope().getLiveVariables();
return std::find(curLiveVars.begin(), curLiveVars.end(), variable) != curLiveVars.end();
}
const vector<Variable*>& VariableManager::getLiveVariables (void) const
{
return getCurVariableScope().getLiveVariables();
}
void VariableManager::declareVariable (Variable* variable)
{
// Remove from cache if exists in there.
std::vector<const ValueEntry*>::iterator pos = std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable));
if (pos != m_entryCache.end())
m_entryCache.erase(pos);
DE_ASSERT(std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable)) == m_entryCache.end());
// Remove from scope stack.
for (vector<ValueScope*>::const_iterator stackIter = m_valueScopeStack.begin(); stackIter != m_valueScopeStack.end(); stackIter++)
{
ValueScope* scope = *stackIter;
scope->removeValue(variable);
}
// Declare in current scope.
getCurVariableScope().declare(variable);
}
const ValueEntry* VariableManager::getValue (const Variable* variable) const
{
vector<const ValueEntry*>::const_iterator pos = std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable));
return pos != m_entryCache.end() ? *pos : DE_NULL;
}
void VariableManager::removeValueFromCurrentScope (const Variable* variable)
{
// Remove from cache
std::vector<const ValueEntry*>::iterator pos = std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable));
DE_ASSERT(pos != m_entryCache.end());
m_entryCache.erase(pos);
// Remove from current scope \note May not exist in there.
getCurValueScope().removeValue(variable);
}
const ValueEntry* VariableManager::getParentValue (const Variable* variable) const
{
if (m_valueScopeStack.size() < 2)
return DE_NULL; // Only single value scope
for (vector<ValueScope*>::const_reverse_iterator i = m_valueScopeStack.rbegin()+1; i != m_valueScopeStack.rend(); i++)
{
const ValueScope* scope = *i;
ValueEntry* entry = scope->findEntry(variable);
if (entry)
return entry;
}
return DE_NULL; // Not found in stack
}
void VariableManager::setValue (const Variable* variable, ConstValueRangeAccess value)
{
ValueScope& curScope = getCurValueScope();
if (!curScope.findEntry(variable))
{
// New value, allocate and update cache.
ValueEntry* newEntry = curScope.allocate(variable);
std::vector<const ValueEntry*>::iterator cachePos = std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable));
if (cachePos != m_entryCache.end())
*cachePos = newEntry;
else
m_entryCache.push_back(newEntry);
}
curScope.setValue(variable, value);
}
void VariableManager::reserve (ReservedScalars& store, int numScalars)
{
DE_ASSERT(store.numScalars == 0);
store.numScalars = numScalars;
m_numAllocatedScalars += numScalars;
}
void VariableManager::release (ReservedScalars& store)
{
m_numAllocatedScalars -= store.numScalars;
store.numScalars = 0;
}
void VariableManager::pushVariableScope (VariableScope& scope)
{
// Expects emtpy scope
DE_ASSERT(scope.getDeclaredVariables().size() == 0);
DE_ASSERT(scope.getLiveVariables().size() == 0);
m_variableScopeStack.push_back(&scope);
}
void VariableManager::popVariableScope (void)
{
VariableScope& curScope = getCurVariableScope();
// Migrate live variables to parent scope.
// Variables allocated in child scopes can be declared in any parent scope but not the other way around.
if (m_variableScopeStack.size() > 1)
{
VariableScope& parentScope = *m_variableScopeStack[m_variableScopeStack.size()-2];
vector<Variable*>& curLiveVars = curScope.getLiveVariables();
vector<Variable*>& parenLiveVars = parentScope.getLiveVariables();
while (!curLiveVars.empty())
{
Variable* liveVar = curLiveVars.back();
parenLiveVars.push_back(liveVar);
curLiveVars.pop_back();
}
}
// All variables should be either migrated to parent or declared (in case of root scope).
DE_ASSERT(curScope.getLiveVariables().size() == 0);
m_variableScopeStack.pop_back();
}
void VariableManager::pushValueScope (ValueScope& scope)
{
// Value scope should be empty
DE_ASSERT(scope.getValues().size() == 0);
m_valueScopeStack.push_back(&scope);
}
void VariableManager::popValueScope (void)
{
ValueScope& oldScope = getCurValueScope();
// Pop scope and clear cache.
m_valueScopeStack.pop_back();
m_entryCache.clear();
// Re-build entry cache.
if (!m_valueScopeStack.empty())
{
ValueScope& newTopScope = getCurValueScope();
// Speed up computing intersections.
map<const Variable*, const ValueEntry*> oldValues;
const vector<ValueEntry*>& oldEntries = oldScope.getValues();
for (vector<ValueEntry*>::const_iterator valueIter = oldEntries.begin(); valueIter != oldEntries.end(); valueIter++)
oldValues[(*valueIter)->getVariable()] = *valueIter;
set<const Variable*> addedVars;
// Re-build based on current stack.
for (vector<ValueScope*>::reverse_iterator scopeIter = m_valueScopeStack.rbegin(); scopeIter != m_valueScopeStack.rend(); scopeIter++)
{
const ValueScope* scope = *scopeIter;
const vector<ValueEntry*>& valueEntries = scope->getValues();
for (vector<ValueEntry*>::const_iterator valueIter = valueEntries.begin(); valueIter != valueEntries.end(); valueIter++)
{
const ValueEntry* entry = *valueIter;
const Variable* var = entry->getVariable();
if (addedVars.find(var) != addedVars.end())
continue; // Already in cache, set deeper in scope stack.
DE_ASSERT(std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(var)) == m_entryCache.end());
if (oldValues.find(var) != oldValues.end())
{
const ValueEntry* oldEntry = oldValues[var];
// Build new intersected value and store into current scope.
ValueRange intersectedValue(var->getType());
DE_ASSERT(oldEntry->getValueRange().intersects(entry->getValueRange())); // Must intersect
ValueRange::computeIntersection(intersectedValue, entry->getValueRange(), oldEntry->getValueRange());
if (!newTopScope.findEntry(var))
newTopScope.allocate(var);
newTopScope.setValue(var, intersectedValue.asAccess());
// Add entry from top scope to cache.
m_entryCache.push_back(newTopScope.findEntry(var));
}
else
m_entryCache.push_back(entry); // Just add to cache.
addedVars.insert(var); // Record as cached variable.
}
}
// Copy entries from popped scope that don't yet exist in the stack.
for (vector<ValueEntry*>::const_iterator valueIter = oldEntries.begin(); valueIter != oldEntries.end(); valueIter++)
{
const ValueEntry* oldEntry = *valueIter;
const Variable* var = oldEntry->getVariable();
if (addedVars.find(var) == addedVars.end())
setValue(var, oldEntry->getValueRange());
}
}
}
} // rsg