android-8.1.0_r81/s

/*-------------------------------------------------------------------------
 * 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