1 /*------------------------------------------------------------------------- 2 * drawElements Quality Program Random Shader Generator 3 * ---------------------------------------------------- 4 * 5 * Copyright 2014 The Android Open Source Project 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief Variable manager. 22 *//*--------------------------------------------------------------------*/ 23 24 #include "rsgVariableManager.hpp" 25 26 #include <algorithm> 27 #include <map> 28 #include <set> 29 30 using std::vector; 31 using std::set; 32 using std::map; 33 34 namespace rsg 35 { 36 37 class SubValueRangeIterator 38 { 39 public: 40 SubValueRangeIterator (const ConstValueRangeAccess& valueRange); 41 ~SubValueRangeIterator (void) {} 42 43 bool hasItem (void) const; 44 ConstValueRangeAccess getItem (void) const; 45 void next (void); 46 47 private: 48 49 vector<ConstValueRangeAccess> m_stack; 50 }; 51 52 SubValueRangeIterator::SubValueRangeIterator (const ConstValueRangeAccess& valueRange) 53 { 54 m_stack.push_back(valueRange); 55 } 56 57 inline bool SubValueRangeIterator::hasItem (void) const 58 { 59 return !m_stack.empty(); 60 } 61 62 inline ConstValueRangeAccess SubValueRangeIterator::getItem (void) const 63 { 64 return m_stack[m_stack.size()-1]; 65 } 66 67 void SubValueRangeIterator::next (void) 68 { 69 ConstValueRangeAccess curItem = getItem(); 70 m_stack.pop_back(); // Remove current 71 72 switch (curItem.getType().getBaseType()) 73 { 74 case VariableType::TYPE_ARRAY: 75 { 76 int numElements = curItem.getType().getNumElements(); 77 for (int ndx = 0; ndx < numElements; ndx++) 78 m_stack.push_back(curItem.member(ndx)); 79 break; 80 } 81 82 case VariableType::TYPE_STRUCT: 83 { 84 int numMembers = (int)curItem.getType().getMembers().size(); 85 for (int ndx = 0; ndx < numMembers; ndx++) 86 m_stack.push_back(curItem.member(ndx)); 87 break; 88 } 89 90 default: 91 break; // \todo [2011-02-03 pyry] Swizzle control? 92 } 93 } 94 95 ValueEntry::ValueEntry (const Variable* variable) 96 : m_variable (variable) 97 , m_valueRange (variable->getType()) 98 { 99 } 100 101 VariableScope::VariableScope (void) 102 { 103 } 104 105 VariableScope::~VariableScope (void) 106 { 107 for (vector<Variable*>::iterator i = m_declaredVariables.begin(); i != m_declaredVariables.end(); i++) 108 delete *i; 109 110 for (vector<Variable*>::iterator i = m_liveVariables.begin(); i != m_liveVariables.end(); i++) 111 delete *i; 112 } 113 114 Variable* VariableScope::allocate (const VariableType& type, Variable::Storage storage, const char* name) 115 { 116 Variable* variable = new Variable(type, storage, name); 117 try 118 { 119 m_liveVariables.push_back(variable); 120 return variable; 121 } 122 catch (const std::exception&) 123 { 124 delete variable; 125 throw; 126 } 127 } 128 129 void VariableScope::declare (Variable* variable) 130 { 131 m_declaredVariables.push_back(variable); 132 removeLive(variable); 133 } 134 135 void VariableScope::removeLive (const Variable* variable) 136 { 137 vector<Variable*>::iterator pos = std::find(m_liveVariables.begin(), m_liveVariables.end(), variable); 138 DE_ASSERT(pos != m_liveVariables.end()); 139 140 // \todo [pyry] Not so efficient 141 m_liveVariables.erase(pos); 142 } 143 144 ValueScope::ValueScope (void) 145 { 146 } 147 148 ValueScope::~ValueScope (void) 149 { 150 clear(); 151 } 152 153 void ValueScope::clear (void) 154 { 155 for (vector<ValueEntry*>::iterator i = m_entries.begin(); i != m_entries.end(); i++) 156 delete *i; 157 m_entries.clear(); 158 } 159 160 ValueEntry* ValueScope::allocate (const Variable* variable) 161 { 162 ValueEntry* entry = new ValueEntry(variable); 163 try 164 { 165 m_entries.push_back(entry); 166 return entry; 167 } 168 catch (const std::exception&) 169 { 170 delete entry; 171 throw; 172 } 173 } 174 175 class CompareEntryVariable 176 { 177 public: 178 CompareEntryVariable (const Variable* variable) 179 : m_variable(variable) 180 { 181 } 182 183 bool operator== (const ValueEntry* entry) const 184 { 185 return entry->getVariable() == m_variable; 186 } 187 188 private: 189 const Variable* m_variable; 190 }; 191 192 bool operator== (const ValueEntry* entry, const CompareEntryVariable& cmp) 193 { 194 return cmp == entry; 195 } 196 197 ValueEntry* ValueScope::findEntry (const Variable* variable) const 198 { 199 vector<ValueEntry*>::const_iterator pos = std::find(m_entries.begin(), m_entries.end(), CompareEntryVariable(variable)); 200 return pos != m_entries.end() ? *pos : DE_NULL; 201 } 202 203 void ValueScope::setValue (const Variable* variable, ConstValueRangeAccess value) 204 { 205 ValueEntry* entry = findEntry(variable); 206 DE_ASSERT(entry); 207 208 ValueRangeAccess dst = entry->getValueRange(); 209 dst.getMin() = value.getMin().value(); 210 dst.getMax() = value.getMax().value(); 211 } 212 213 void ValueScope::removeValue (const Variable* variable) 214 { 215 vector<ValueEntry*>::iterator pos = std::find(m_entries.begin(), m_entries.end(), CompareEntryVariable(variable)); 216 if (pos != m_entries.end()) 217 { 218 ValueEntry* entry = *pos; 219 m_entries.erase(pos); 220 delete entry; 221 } 222 } 223 224 VariableManager::VariableManager (NameAllocator& nameAllocator) 225 : m_numAllocatedScalars (0) 226 , m_numAllocatedShaderInScalars (0) 227 , m_numAllocatedShaderInVariables (0) 228 , m_numAllocatedUniformScalars (0) 229 , m_nameAllocator (nameAllocator) 230 { 231 } 232 233 VariableManager::~VariableManager (void) 234 { 235 } 236 237 Variable* VariableManager::allocate (const VariableType& type) 238 { 239 return allocate(type, Variable::STORAGE_LOCAL, m_nameAllocator.allocate().c_str()); 240 } 241 242 Variable* VariableManager::allocate (const VariableType& type, Variable::Storage storage, const char* name) 243 { 244 VariableScope& varScope = getCurVariableScope(); 245 ValueScope& valueScope = getCurValueScope(); 246 int numScalars = type.getScalarSize(); 247 248 // Allocate in current scope 249 Variable* variable = varScope.allocate(type, Variable::STORAGE_LOCAL, name); 250 251 // Allocate value entry 252 ValueEntry* valueEntry = valueScope.allocate(variable); 253 254 // Add to cache 255 m_entryCache.push_back(valueEntry); 256 257 m_numAllocatedScalars += numScalars; 258 259 // Set actual storage - affects uniform/shader in allocations. 260 setStorage(variable, storage); 261 262 return variable; 263 } 264 265 void VariableManager::setStorage (Variable* variable, Variable::Storage storage) 266 { 267 int numScalars = variable->getType().getScalarSize(); 268 269 // Decrement old. 270 if (variable->getStorage() == Variable::STORAGE_SHADER_IN) 271 { 272 m_numAllocatedShaderInScalars -= numScalars; 273 m_numAllocatedShaderInVariables -= 1; 274 } 275 else if (variable->getStorage() == Variable::STORAGE_UNIFORM) 276 m_numAllocatedUniformScalars -= numScalars; 277 278 // Add new. 279 if (storage == Variable::STORAGE_SHADER_IN) 280 { 281 m_numAllocatedShaderInScalars += numScalars; 282 m_numAllocatedShaderInVariables += 1; 283 } 284 else if (storage == Variable::STORAGE_UNIFORM) 285 m_numAllocatedUniformScalars += numScalars; 286 287 variable->setStorage(storage); 288 } 289 290 bool VariableManager::canDeclareInCurrentScope (const Variable* variable) const 291 { 292 const vector<Variable*>& curLiveVars = getCurVariableScope().getLiveVariables(); 293 return std::find(curLiveVars.begin(), curLiveVars.end(), variable) != curLiveVars.end(); 294 } 295 296 const vector<Variable*>& VariableManager::getLiveVariables (void) const 297 { 298 return getCurVariableScope().getLiveVariables(); 299 } 300 301 void VariableManager::declareVariable (Variable* variable) 302 { 303 // Remove from cache if exists in there. 304 std::vector<const ValueEntry*>::iterator pos = std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable)); 305 if (pos != m_entryCache.end()) 306 m_entryCache.erase(pos); 307 308 DE_ASSERT(std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable)) == m_entryCache.end()); 309 310 // Remove from scope stack. 311 for (vector<ValueScope*>::const_iterator stackIter = m_valueScopeStack.begin(); stackIter != m_valueScopeStack.end(); stackIter++) 312 { 313 ValueScope* scope = *stackIter; 314 scope->removeValue(variable); 315 } 316 317 // Declare in current scope. 318 getCurVariableScope().declare(variable); 319 } 320 321 const ValueEntry* VariableManager::getValue (const Variable* variable) const 322 { 323 vector<const ValueEntry*>::const_iterator pos = std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable)); 324 return pos != m_entryCache.end() ? *pos : DE_NULL; 325 } 326 327 void VariableManager::removeValueFromCurrentScope (const Variable* variable) 328 { 329 // Remove from cache 330 std::vector<const ValueEntry*>::iterator pos = std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable)); 331 DE_ASSERT(pos != m_entryCache.end()); 332 m_entryCache.erase(pos); 333 334 // Remove from current scope \note May not exist in there. 335 getCurValueScope().removeValue(variable); 336 } 337 338 const ValueEntry* VariableManager::getParentValue (const Variable* variable) const 339 { 340 if (m_valueScopeStack.size() < 2) 341 return DE_NULL; // Only single value scope 342 343 for (vector<ValueScope*>::const_reverse_iterator i = m_valueScopeStack.rbegin()+1; i != m_valueScopeStack.rend(); i++) 344 { 345 const ValueScope* scope = *i; 346 ValueEntry* entry = scope->findEntry(variable); 347 348 if (entry) 349 return entry; 350 } 351 352 return DE_NULL; // Not found in stack 353 } 354 355 void VariableManager::setValue (const Variable* variable, ConstValueRangeAccess value) 356 { 357 ValueScope& curScope = getCurValueScope(); 358 359 if (!curScope.findEntry(variable)) 360 { 361 // New value, allocate and update cache. 362 ValueEntry* newEntry = curScope.allocate(variable); 363 std::vector<const ValueEntry*>::iterator cachePos = std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(variable)); 364 365 if (cachePos != m_entryCache.end()) 366 *cachePos = newEntry; 367 else 368 m_entryCache.push_back(newEntry); 369 } 370 371 curScope.setValue(variable, value); 372 } 373 374 void VariableManager::reserve (ReservedScalars& store, int numScalars) 375 { 376 DE_ASSERT(store.numScalars == 0); 377 store.numScalars = numScalars; 378 m_numAllocatedScalars += numScalars; 379 } 380 381 void VariableManager::release (ReservedScalars& store) 382 { 383 m_numAllocatedScalars -= store.numScalars; 384 store.numScalars = 0; 385 } 386 387 void VariableManager::pushVariableScope (VariableScope& scope) 388 { 389 // Expects emtpy scope 390 DE_ASSERT(scope.getDeclaredVariables().size() == 0); 391 DE_ASSERT(scope.getLiveVariables().size() == 0); 392 393 m_variableScopeStack.push_back(&scope); 394 } 395 396 void VariableManager::popVariableScope (void) 397 { 398 VariableScope& curScope = getCurVariableScope(); 399 400 // Migrate live variables to parent scope. 401 // Variables allocated in child scopes can be declared in any parent scope but not the other way around. 402 if (m_variableScopeStack.size() > 1) 403 { 404 VariableScope& parentScope = *m_variableScopeStack[m_variableScopeStack.size()-2]; 405 vector<Variable*>& curLiveVars = curScope.getLiveVariables(); 406 vector<Variable*>& parenLiveVars = parentScope.getLiveVariables(); 407 408 while (!curLiveVars.empty()) 409 { 410 Variable* liveVar = curLiveVars.back(); 411 parenLiveVars.push_back(liveVar); 412 curLiveVars.pop_back(); 413 } 414 } 415 416 // All variables should be either migrated to parent or declared (in case of root scope). 417 DE_ASSERT(curScope.getLiveVariables().size() == 0); 418 419 m_variableScopeStack.pop_back(); 420 } 421 422 void VariableManager::pushValueScope (ValueScope& scope) 423 { 424 // Value scope should be empty 425 DE_ASSERT(scope.getValues().size() == 0); 426 427 m_valueScopeStack.push_back(&scope); 428 } 429 430 void VariableManager::popValueScope (void) 431 { 432 ValueScope& oldScope = getCurValueScope(); 433 434 // Pop scope and clear cache. 435 m_valueScopeStack.pop_back(); 436 m_entryCache.clear(); 437 438 // Re-build entry cache. 439 if (!m_valueScopeStack.empty()) 440 { 441 ValueScope& newTopScope = getCurValueScope(); 442 443 // Speed up computing intersections. 444 map<const Variable*, const ValueEntry*> oldValues; 445 const vector<ValueEntry*>& oldEntries = oldScope.getValues(); 446 447 for (vector<ValueEntry*>::const_iterator valueIter = oldEntries.begin(); valueIter != oldEntries.end(); valueIter++) 448 oldValues[(*valueIter)->getVariable()] = *valueIter; 449 450 set<const Variable*> addedVars; 451 452 // Re-build based on current stack. 453 for (vector<ValueScope*>::reverse_iterator scopeIter = m_valueScopeStack.rbegin(); scopeIter != m_valueScopeStack.rend(); scopeIter++) 454 { 455 const ValueScope* scope = *scopeIter; 456 const vector<ValueEntry*>& valueEntries = scope->getValues(); 457 458 for (vector<ValueEntry*>::const_iterator valueIter = valueEntries.begin(); valueIter != valueEntries.end(); valueIter++) 459 { 460 const ValueEntry* entry = *valueIter; 461 const Variable* var = entry->getVariable(); 462 463 if (addedVars.find(var) != addedVars.end()) 464 continue; // Already in cache, set deeper in scope stack. 465 466 DE_ASSERT(std::find(m_entryCache.begin(), m_entryCache.end(), CompareEntryVariable(var)) == m_entryCache.end()); 467 468 if (oldValues.find(var) != oldValues.end()) 469 { 470 const ValueEntry* oldEntry = oldValues[var]; 471 472 // Build new intersected value and store into current scope. 473 ValueRange intersectedValue(var->getType()); 474 DE_ASSERT(oldEntry->getValueRange().intersects(entry->getValueRange())); // Must intersect 475 ValueRange::computeIntersection(intersectedValue, entry->getValueRange(), oldEntry->getValueRange()); 476 477 if (!newTopScope.findEntry(var)) 478 newTopScope.allocate(var); 479 480 newTopScope.setValue(var, intersectedValue.asAccess()); 481 482 // Add entry from top scope to cache. 483 m_entryCache.push_back(newTopScope.findEntry(var)); 484 } 485 else 486 m_entryCache.push_back(entry); // Just add to cache. 487 488 addedVars.insert(var); // Record as cached variable. 489 } 490 } 491 492 // Copy entries from popped scope that don't yet exist in the stack. 493 for (vector<ValueEntry*>::const_iterator valueIter = oldEntries.begin(); valueIter != oldEntries.end(); valueIter++) 494 { 495 const ValueEntry* oldEntry = *valueIter; 496 const Variable* var = oldEntry->getVariable(); 497 498 if (addedVars.find(var) == addedVars.end()) 499 setValue(var, oldEntry->getValueRange()); 500 } 501 } 502 } 503 504 } // rsg 505
