framework/randomshaders/rsgVariableManager.hpp

   1 #ifndef _RSGVARIABLEMANAGER_HPP
   2 #define _RSGVARIABLEMANAGER_HPP
   3 /*-------------------------------------------------------------------------
   4  * drawElements Quality Program Random Shader Generator
   5  * ----------------------------------------------------
   6  *
   7  * Copyright 2014 The Android Open Source Project
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  *      http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  *
  21  *//*!
  22  * \file
  23  * \brief Variable manager.
  24  *
  25  * Memory management:
  26  *  Variable manager owns variable objects until they are either explictly
  27  *  removed or moved to currently active scope. After that the ownership
  28  *  is transferred to Scope or the object that called removeEntry().
  29  *//*--------------------------------------------------------------------*/
  30
  31 #include "rsgDefs.hpp"
  32 #include "rsgVariable.hpp"
  33 #include "rsgVariableValue.hpp"
  34 #include "rsgNameAllocator.hpp"
  35
  36 #include <iterator>
  37 #include <vector>
  38 #include <set>
  39
  40 namespace rsg
  41 {
  42
  43 class ValueEntry
  44 {
  45 public:
  46                                                         ValueEntry                              (const Variable* variable);
  47                                                         ~ValueEntry                             (void) {}
  48
  49         const Variable*                 getVariable                             (void) const    { return m_variable;    }
  50
  51         ConstValueRangeAccess   getValueRange                   (void) const    { return m_valueRange.asAccess();       }
  52         ValueRangeAccess                getValueRange                   (void)                  { return m_valueRange.asAccess();       }
  53
  54 private:
  55         const Variable*                 m_variable;
  56         ValueRange                              m_valueRange;
  57 };
  58
  59 // Variable scope manages variable allocation.
  60 class VariableScope
  61 {
  62 public:
  63                                                                                 VariableScope                   (void);
  64                                                                                 ~VariableScope                  (void);
  65
  66         Variable*                                                       allocate                                (const VariableType& type, Variable::Storage storage, const char* name);
  67         void                                                            declare                                 (Variable* variable);           //!< Move from live set to declared set
  68         void                                                            removeLive                              (const Variable* variable);     //!< Just remove from live set (when migrating to parent).
  69
  70         const std::vector<Variable*>&           getDeclaredVariables    (void) const    { return m_declaredVariables;   }
  71
  72         std::vector<Variable*>&                         getLiveVariables                (void)                  { return m_liveVariables;               }
  73         const std::vector<Variable*>&           getLiveVariables                (void) const    { return m_liveVariables;               }
  74
  75 private:
  76                                                                                 VariableScope                   (const VariableScope& other);
  77         VariableScope&                                          operator=                               (const VariableScope& other);
  78
  79         std::vector<Variable*>                          m_declaredVariables;    //!< Variables declared in this scope. Not available for expressions.
  80         std::vector<Variable*>                          m_liveVariables;                //!< Live variables (available for expression) that can be declared in this scope.
  81 };
  82
  83 class ValueScope
  84 {
  85 public:
  86                                                                                 ValueScope                              (void);
  87                                                                                 ~ValueScope                             (void);
  88
  89         ValueEntry*                                                     allocate                                (const Variable* variable);
  90         ValueEntry*                                                     findEntry                               (const Variable* variable) const;
  91         void                                                            setValue                                (const Variable* variable, ConstValueRangeAccess value);
  92         void                                                            removeValue                             (const Variable* variable);
  93
  94         std::vector<ValueEntry*>&                       getValues                               (void)                  { return m_entries;     }
  95         const std::vector<ValueEntry*>&         getValues                               (void) const    { return m_entries; }
  96
  97         void                                                            clear                                   (void);
  98
  99 private:
 100                                                                                 ValueScope                              (const ValueScope& other);
 101         ValueScope&                                                     operator=                               (const ValueScope& other);
 102
 103         std::vector<ValueEntry*>                        m_entries;
 104 };
 105
 106 class ReservedScalars
 107 {
 108 public:
 109         int numScalars;
 110
 111         ReservedScalars (void)
 112                 : numScalars(0)
 113         {
 114         }
 115 };
 116
 117 // \todo [2011-05-26 pyry] Clean up this a bit, separate const variant.
 118 template <typename Item, typename Iterator, class Filter>
 119 class FilteredIterator : public std::iterator<std::input_iterator_tag, Item>
 120 {
 121 public:
 122         FilteredIterator (Iterator iter, Iterator end, Filter filter)
 123                 : m_iter        (iter)
 124                 , m_end         (end)
 125                 , m_filter      (filter)
 126         {
 127         }
 128
 129         FilteredIterator operator+ (ptrdiff_t offset) const
 130         {
 131                 Iterator nextEntry = m_iter;
 132                 while (offset--)
 133                         nextEntry = findNext(m_filter, nextEntry, m_end);
 134                 return FilteredIterator(nextEntry, m_end, m_filter);
 135         }
 136
 137         FilteredIterator& operator++ ()
 138         {
 139                 // Pre-increment
 140                 m_iter = findNext(m_filter, m_iter, m_end);
 141                 return *this;
 142         }
 143
 144         FilteredIterator operator++ (int)
 145         {
 146                 // Post-increment
 147                 FilteredIterator copy = *this;
 148                 m_iter = findNext(m_filter, m_iter, m_end);
 149                 return copy;
 150         }
 151
 152         bool operator== (const FilteredIterator& other) const
 153         {
 154                 return m_iter == other.m_iter;
 155         }
 156
 157         bool operator!= (const FilteredIterator& other) const
 158         {
 159                 return m_iter != other.m_iter;
 160         }
 161
 162         const Item& operator* (void)
 163         {
 164                 DE_ASSERT(m_iter != m_end);
 165                 DE_ASSERT(m_filter(*m_iter));
 166                 return *m_iter;
 167         }
 168
 169 private:
 170         static Iterator findNext (Filter filter, Iterator iter, Iterator end)
 171         {
 172                 do
 173                         iter++;
 174                 while (iter != end && !filter(*iter));
 175                 return iter;
 176         }
 177
 178         Iterator                m_iter;
 179         Iterator                m_end;
 180         Filter                  m_filter;
 181 };
 182
 183 template <class Filter>
 184 class ValueEntryIterator : public FilteredIterator<const ValueEntry*, std::vector<const ValueEntry*>::const_iterator, Filter>
 185 {
 186 public:
 187         ValueEntryIterator (std::vector<const ValueEntry*>::const_iterator begin, std::vector<const ValueEntry*>::const_iterator end, Filter filter)
 188                 : FilteredIterator<const ValueEntry*, std::vector<const ValueEntry*>::const_iterator, Filter>(begin, end, filter)
 189         {
 190         }
 191 };
 192
 193 class VariableManager
 194 {
 195 public:
 196                                                                         VariableManager                                 (NameAllocator& nameAllocator);
 197                                                                         ~VariableManager                                (void);
 198
 199         int                                                             getNumAllocatedScalars                  (void) const { return m_numAllocatedScalars; }
 200         int                                                             getNumAllocatedShaderInScalars  (void) const { return m_numAllocatedShaderInScalars; }
 201         int                                                             getNumAllocatedShaderInVariables(void) const { return m_numAllocatedShaderInVariables; }
 202         int                                                             getNumAllocatedUniformScalars   (void) const { return m_numAllocatedUniformScalars; }
 203
 204         void                                                    reserve                                                 (ReservedScalars& store, int numScalars);
 205         void                                                    release                                                 (ReservedScalars& store);
 206
 207         Variable*                                               allocate                                                (const VariableType& type);
 208         Variable*                                               allocate                                                (const VariableType& type, Variable::Storage storage, const char* name);
 209
 210         void                                                    setStorage                                              (Variable* variable, Variable::Storage storage);
 211
 212         void                                                    setValue                                                (const Variable* variable, ConstValueRangeAccess value);
 213         const ValueEntry*                               getValue                                                (const Variable* variable) const;
 214         const ValueEntry*                               getParentValue                                  (const Variable* variable) const;
 215
 216         void                                                    removeValueFromCurrentScope             (const Variable* variable);
 217
 218         void                                                    declareVariable                                 (Variable* variable);
 219         bool                                                    canDeclareInCurrentScope                (const Variable* variable) const;
 220         const std::vector<Variable*>&   getLiveVariables                                (void) const;
 221
 222         void                                                    pushVariableScope                               (VariableScope& scope);
 223         void                                                    popVariableScope                                (void);
 224
 225         void                                                    pushValueScope                                  (ValueScope& scope);
 226         void                                                    popValueScope                                   (void);
 227
 228         template <class Filter>
 229         ValueEntryIterator<Filter>              getBegin                                                (Filter filter = Filter()) const;
 230
 231         template <class Filter>
 232         ValueEntryIterator<Filter>              getEnd                                                  (Filter filter = Filter()) const;
 233
 234         template <class Filter>
 235         bool                                                    hasEntry                                                (Filter filter = Filter()) const;
 236
 237 private:
 238                                                                         VariableManager                                 (const VariableManager& other);
 239         VariableManager&                                operator=                                               (const VariableManager& other);
 240
 241         VariableScope&                                  getCurVariableScope                             (void)                  { return *m_variableScopeStack.back();  }
 242         const VariableScope&                    getCurVariableScope                             (void) const    { return *m_variableScopeStack.back();  }
 243
 244         ValueScope&                                             getCurValueScope                                (void)                  { return *m_valueScopeStack.back();     }
 245         const ValueScope&                               getCurValueScope                                (void) const    { return *m_valueScopeStack.back();     }
 246
 247         std::vector<VariableScope*>             m_variableScopeStack;
 248         std::vector<ValueScope*>                m_valueScopeStack;
 249
 250         std::vector<const ValueEntry*>  m_entryCache;   //!< For faster value entry access.
 251
 252         int                                                             m_numAllocatedScalars;
 253         int                                                             m_numAllocatedShaderInScalars;
 254         int                                                             m_numAllocatedShaderInVariables;
 255         int                                                             m_numAllocatedUniformScalars;
 256         NameAllocator&                                  m_nameAllocator;
 257 };
 258
 259 template <class Filter>
 260 ValueEntryIterator<Filter> VariableManager::getBegin (Filter filter) const
 261 {
 262         std::vector<const ValueEntry*>::const_iterator first = m_entryCache.begin();
 263         while (first != m_entryCache.end() && !filter(*first))
 264                 first++;
 265         return ValueEntryIterator<Filter>(first, m_entryCache.end(), filter);
 266 }
 267
 268 template <class Filter>
 269 ValueEntryIterator<Filter> VariableManager::getEnd (Filter filter) const
 270 {
 271         return ValueEntryIterator<Filter>(m_entryCache.end(), m_entryCache.end(), filter);
 272 }
 273
 274 template <class Filter>
 275 bool VariableManager::hasEntry (Filter filter) const
 276 {
 277         for (std::vector<const ValueEntry*>::const_iterator i = m_entryCache.begin(); i != m_entryCache.end(); i++)
 278         {
 279                 if (filter(*i))
 280                         return true;
 281         }
 282         return false;
 283 }
 284
 285 // Common filters
 286
 287 class AnyEntry
 288 {
 289 public:
 290         typedef ValueEntryIterator<AnyEntry> Iterator;
 291
 292         bool operator() (const ValueEntry* entry) const
 293         {
 294                 DE_UNREF(entry);
 295                 return true;
 296         }
 297 };
 298
 299 class IsWritableEntry
 300 {
 301 public:
 302         bool operator() (const ValueEntry* entry) const
 303         {
 304                 switch (entry->getVariable()->getStorage())
 305                 {
 306                         case Variable::STORAGE_LOCAL:
 307                         case Variable::STORAGE_SHADER_OUT:
 308                         case Variable::STORAGE_PARAMETER_IN:
 309                         case Variable::STORAGE_PARAMETER_OUT:
 310                         case Variable::STORAGE_PARAMETER_INOUT:
 311                                 return true;
 312
 313                         default:
 314                                 return false;
 315                 }
 316         }
 317 };
 318
 319 template <Variable::Storage Storage>
 320 class EntryStorageFilter
 321 {
 322 public:
 323         typedef ValueEntryIterator<EntryStorageFilter<Storage> > Iterator;
 324
 325         bool operator() (const ValueEntry* entry) const
 326         {
 327                 return entry->getVariable()->getStorage() == Storage;
 328         }
 329 };
 330
 331 typedef EntryStorageFilter<Variable::STORAGE_LOCAL>                     LocalEntryFilter;
 332 typedef EntryStorageFilter<Variable::STORAGE_SHADER_IN>         ShaderInEntryFilter;
 333 typedef EntryStorageFilter<Variable::STORAGE_SHADER_OUT>        ShaderOutEntryFilter;
 334
 335 } // rsg
 336
 337 #endif // _RSGVARIABLEMANAGER_HPP