framework/randomshaders/rsgStatement.cpp

   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 Statements.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "rsgStatement.hpp"
  25 #include "rsgExpressionGenerator.hpp"
  26 #include "rsgUtils.hpp"
  27
  28 #include <typeinfo>
  29
  30 using std::vector;
  31
  32 namespace rsg
  33 {
  34
  35 namespace
  36 {
  37
  38 inline bool isCurrentTopStatementBlock (const GeneratorState& state)
  39 {
  40         int stackDepth = state.getStatementDepth();
  41         return dynamic_cast<const BlockStatement*>(state.getStatementStackEntry(stackDepth-1)) != DE_NULL;
  42 }
  43
  44 template <class T> float                getWeight       (const GeneratorState& state)   { return T::getWeight(state);   }
  45 template <class T> Statement*   create          (GeneratorState& state)                 { return new T(state);                  }
  46
  47 struct StatementSpec
  48 {
  49         float           (*getWeight)            (const GeneratorState& state);
  50         Statement*      (*create)                       (GeneratorState& state);
  51 };
  52
  53 const StatementSpec* chooseStatement (GeneratorState& state)
  54 {
  55         static const StatementSpec statementSpecs[] =
  56         {
  57                 { getWeight<BlockStatement>,            create<BlockStatement>                  },
  58                 { getWeight<ExpressionStatement>,       create<ExpressionStatement>             },
  59                 { getWeight<DeclarationStatement>,      create<DeclarationStatement>    },
  60                 { getWeight<ConditionalStatement>,      create<ConditionalStatement>    }
  61         };
  62
  63         float weights[DE_LENGTH_OF_ARRAY(statementSpecs)];
  64
  65         // Compute weights
  66         float sum = 0.0f;
  67         for (int ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(statementSpecs); ndx++)
  68         {
  69                 weights[ndx] = statementSpecs[ndx].getWeight(state);
  70                 sum += weights[ndx];
  71         }
  72
  73         DE_ASSERT(sum > 0.0f);
  74
  75         // Random number in range
  76         float p = state.getRandom().getFloat(0.0f, sum);
  77
  78         const StatementSpec* spec                       = DE_NULL;
  79         const StatementSpec* lastNonZero        = DE_NULL;
  80
  81         // Find element in that point
  82         sum = 0.0f;
  83         for (int ndx = 0; ndx < (int)DE_LENGTH_OF_ARRAY(statementSpecs); ndx++)
  84         {
  85                 sum += weights[ndx];
  86                 if (p < sum)
  87                 {
  88                         spec = &statementSpecs[ndx];
  89                         break;
  90                 }
  91                 else if (weights[ndx] > 0.0f)
  92                         lastNonZero = &statementSpecs[ndx];
  93         }
  94
  95         if (!spec)
  96                 spec = lastNonZero;
  97
  98         return spec;
  99 }
 100
 101 Statement* createStatement (GeneratorState& state)
 102 {
 103         return chooseStatement(state)->create(state);
 104 }
 105
 106 } // anonymous
 107
 108 Statement::Statement (void)
 109 {
 110 }
 111
 112 Statement::~Statement (void)
 113 {
 114 }
 115
 116 ExpressionStatement::ExpressionStatement (GeneratorState& state)
 117         : m_expression(DE_NULL)
 118 {
 119         ExpressionGenerator generator(state);
 120         m_expression = generator.generate(ValueRange(VariableType(VariableType::TYPE_VOID)));
 121 }
 122
 123 ExpressionStatement::~ExpressionStatement (void)
 124 {
 125         delete m_expression;
 126 }
 127
 128 float ExpressionStatement::getWeight (const GeneratorState& state)
 129 {
 130         DE_UNREF(state);
 131         return 1.0f;
 132 }
 133
 134 void ExpressionStatement::execute (ExecutionContext& execCtx) const
 135 {
 136         m_expression->evaluate(execCtx);
 137 }
 138
 139 BlockStatement::BlockStatement (GeneratorState& state)
 140 {
 141         init(state);
 142 }
 143
 144 void BlockStatement::init (GeneratorState& state)
 145 {
 146         // Select number of children statements to construct
 147         m_numChildrenToCreate = state.getRandom().getInt(0, state.getShaderParameters().maxStatementsPerBlock);
 148
 149         // Push scope
 150         state.getVariableManager().pushVariableScope(m_scope);
 151 }
 152
 153 BlockStatement::~BlockStatement (void)
 154 {
 155         for (vector<Statement*>::iterator i = m_children.begin(); i != m_children.end(); i++)
 156                 delete *i;
 157         m_children.clear();
 158 }
 159
 160 void BlockStatement::addChild (Statement* statement)
 161 {
 162         try
 163         {
 164                 m_children.push_back(statement);
 165         }
 166         catch (const std::exception&)
 167         {
 168                 delete statement;
 169                 throw;
 170         }
 171 }
 172
 173 Statement* BlockStatement::createNextChild (GeneratorState& state)
 174 {
 175         if ((int)m_children.size() < m_numChildrenToCreate)
 176         {
 177                 // Select and create a new child
 178                 Statement* child = createStatement(state);
 179                 addChild(child);
 180                 return child;
 181         }
 182         else
 183         {
 184                 // Done, pop scope
 185                 state.getVariableManager().popVariableScope();
 186                 return DE_NULL;
 187         }
 188 }
 189
 190 float BlockStatement::getWeight (const GeneratorState& state)
 191 {
 192         if (state.getStatementDepth()+1 < state.getShaderParameters().maxStatementDepth)
 193         {
 194                 if (isCurrentTopStatementBlock(state))
 195                         return 0.2f; // Low probability for anonymous blocks.
 196                 else
 197                         return 1.0f;
 198         }
 199         else
 200                 return 0.0f;
 201 }
 202
 203 void BlockStatement::tokenize (GeneratorState& state, TokenStream& str) const
 204 {
 205         str << Token::LEFT_BRACE << Token::NEWLINE << Token::INDENT_INC;
 206
 207         for (vector<Statement*>::const_reverse_iterator i = m_children.rbegin(); i != m_children.rend(); i++)
 208                 (*i)->tokenize(state, str);
 209
 210         str << Token::INDENT_DEC << Token::RIGHT_BRACE << Token::NEWLINE;
 211 }
 212
 213 void BlockStatement::execute (ExecutionContext& execCtx) const
 214 {
 215         for (vector<Statement*>::const_reverse_iterator i = m_children.rbegin(); i != m_children.rend(); i++)
 216                 (*i)->execute(execCtx);
 217 }
 218
 219 void ExpressionStatement::tokenize (GeneratorState& state, TokenStream& str) const
 220 {
 221         DE_ASSERT(m_expression);
 222         m_expression->tokenize(state, str);
 223         str << Token::SEMICOLON << Token::NEWLINE;
 224 }
 225
 226 namespace
 227 {
 228
 229 inline bool canDeclareVariable (const Variable* variable)
 230 {
 231         return variable->getStorage() == Variable::STORAGE_LOCAL;
 232 }
 233
 234 bool hasDeclarableVars (const VariableManager& varMgr)
 235 {
 236         const vector<Variable*>& liveVars = varMgr.getLiveVariables();
 237         for (vector<Variable*>::const_iterator i = liveVars.begin(); i != liveVars.end(); i++)
 238         {
 239                 if (canDeclareVariable(*i))
 240                         return true;
 241         }
 242         return false;
 243 }
 244
 245 } // anonymous
 246
 247 DeclarationStatement::DeclarationStatement (GeneratorState& state, Variable* variable)
 248         : m_variable    (DE_NULL)
 249         , m_expression  (DE_NULL)
 250 {
 251         if (variable == DE_NULL)
 252         {
 253                 // Choose random
 254                 // \todo [2011-02-03 pyry] Allocate a new here?
 255                 // \todo [2011-05-26 pyry] Weights?
 256                 const vector<Variable*>&        liveVars = state.getVariableManager().getLiveVariables();
 257                 vector<Variable*>                       candidates;
 258
 259                 for (vector<Variable*>::const_iterator i = liveVars.begin(); i != liveVars.end(); i++)
 260                 {
 261                         if (canDeclareVariable(*i))
 262                                 candidates.push_back(*i);
 263                 }
 264
 265                 variable = state.getRandom().choose<Variable*>(candidates.begin(), candidates.end());
 266         }
 267
 268         DE_ASSERT(variable);
 269         m_variable = variable;
 270
 271         const ValueEntry* value = state.getVariableManager().getValue(variable);
 272
 273         bool createInitializer = false;
 274
 275         switch (m_variable->getStorage())
 276         {
 277                 case Variable::STORAGE_CONST:
 278                         DE_ASSERT(value);
 279                         createInitializer = true;
 280                         break;
 281
 282                 case Variable::STORAGE_LOCAL:
 283                         // \note Currently booleans are always treated as not having undefined range and thus
 284                         //       initializer is always created.
 285                         createInitializer = value && !isUndefinedValueRange(value->getValueRange());
 286                         break;
 287
 288                 default:
 289                         createInitializer = false;
 290                         break;
 291         }
 292
 293         if (createInitializer)
 294         {
 295                 ExpressionGenerator generator(state);
 296
 297                 // Take copy of value range for generating initializer expression
 298                 ValueRange valueRange = value->getValueRange();
 299
 300                 // Declare (removes value entry)
 301                 state.getVariableManager().declareVariable(variable);
 302
 303                 bool isConst = m_variable->getStorage() == Variable::STORAGE_CONST;
 304
 305                 if (isConst)
 306                         state.pushExpressionFlags(state.getExpressionFlags() | CONST_EXPR);
 307
 308                 m_expression = generator.generate(valueRange, 1);
 309
 310                 if (isConst)
 311                         state.popExpressionFlags();
 312         }
 313         else
 314                 state.getVariableManager().declareVariable(variable);
 315 }
 316
 317 DeclarationStatement::~DeclarationStatement (void)
 318 {
 319         delete m_expression;
 320 }
 321
 322 float DeclarationStatement::getWeight (const GeneratorState& state)
 323 {
 324         if (!hasDeclarableVars(state.getVariableManager()))
 325                 return 0.0f;
 326
 327         if (!isCurrentTopStatementBlock(state))
 328                 return 0.0f;
 329
 330         return state.getProgramParameters().declarationStatementBaseWeight;
 331 }
 332
 333 void DeclarationStatement::tokenize (GeneratorState& state, TokenStream& str) const
 334 {
 335         m_variable->tokenizeDeclaration(state, str);
 336
 337         if (m_expression)
 338         {
 339                 str << Token::EQUAL;
 340                 m_expression->tokenize(state, str);
 341         }
 342
 343         str << Token::SEMICOLON << Token::NEWLINE;
 344 }
 345
 346 void DeclarationStatement::execute (ExecutionContext& execCtx) const
 347 {
 348         if (m_expression)
 349         {
 350                 m_expression->evaluate(execCtx);
 351                 execCtx.getValue(m_variable) = m_expression->getValue().value();
 352         }
 353 }
 354
 355 ConditionalStatement::ConditionalStatement (GeneratorState&)
 356         : m_condition           (DE_NULL)
 357         , m_trueStatement       (DE_NULL)
 358         , m_falseStatement      (DE_NULL)
 359 {
 360 }
 361
 362 ConditionalStatement::~ConditionalStatement (void)
 363 {
 364         delete m_condition;
 365         delete m_trueStatement;
 366         delete m_falseStatement;
 367 }
 368
 369 bool ConditionalStatement::isElseBlockRequired (const GeneratorState& state) const
 370 {
 371         // If parent is conditional statement with else block and this is the true statement,
 372         // else block must be generated or otherwise parent "else" will end up parsed as else statement for this if.
 373         const ConditionalStatement*     curChild        = this;
 374         int                                                     curStackNdx     = state.getStatementDepth()-2;
 375
 376         while (curStackNdx >= 0)
 377         {
 378                 const ConditionalStatement* curParent = dynamic_cast<const ConditionalStatement*>(state.getStatementStackEntry(curStackNdx));
 379
 380                 if (!curParent)
 381                         break; // Not a conditional statement - can end search here.
 382
 383                 if (curChild == curParent->m_trueStatement && curParent->m_falseStatement)
 384                         return true; // Else block is mandatory.
 385
 386                 // Continue search.
 387                 curChild         = curParent;
 388                 curStackNdx     -= 1;
 389         }
 390
 391         return false;
 392 }
 393
 394 Statement* ConditionalStatement::createNextChild (GeneratorState& state)
 395 {
 396         // If has neither true or false statements, choose randomly whether to create false block.
 397         if (!m_falseStatement && !m_trueStatement && (isElseBlockRequired(state) || state.getRandom().getBool()))
 398         {
 399                 // Construct false statement
 400                 state.getVariableManager().pushValueScope(m_conditionalScope);
 401                 m_falseStatement = createStatement(state);
 402
 403                 return m_falseStatement;
 404         }
 405         else if (!m_trueStatement)
 406         {
 407                 if (m_falseStatement)
 408                 {
 409                         // Pop previous value scope.
 410                         state.getVariableManager().popValueScope();
 411                         m_conditionalScope.clear();
 412                 }
 413
 414                 // Construct true statement
 415                 state.getVariableManager().pushValueScope(m_conditionalScope);
 416                 m_trueStatement = createStatement(state);
 417
 418                 return m_trueStatement;
 419         }
 420         else
 421         {
 422                 // Pop conditional scope.
 423                 state.getVariableManager().popValueScope();
 424                 m_conditionalScope.clear();
 425
 426                 // Create condition
 427                 DE_ASSERT(!m_condition);
 428
 429                 ExpressionGenerator generator(state);
 430
 431                 ValueRange range = ValueRange(VariableType::getScalarType(VariableType::TYPE_BOOL));
 432                 range.getMin().asBool() = false;
 433                 range.getMax().asBool() = true;
 434
 435                 m_condition = generator.generate(range, 1);
 436
 437                 return DE_NULL; // Done with this statement
 438         }
 439 }
 440
 441 namespace
 442 {
 443
 444 bool isBlockStatement (const Statement* statement)
 445 {
 446         return dynamic_cast<const BlockStatement*>(statement) != DE_NULL;
 447 }
 448
 449 bool isConditionalStatement (const Statement* statement)
 450 {
 451         return dynamic_cast<const ConditionalStatement*>(statement) != DE_NULL;
 452 }
 453
 454 } // anonymous
 455
 456 void ConditionalStatement::tokenize (GeneratorState& state, TokenStream& str) const
 457 {
 458         DE_ASSERT(m_condition && m_trueStatement);
 459
 460         // if (condition)
 461         str << Token::IF << Token::LEFT_PAREN;
 462         m_condition->tokenize(state, str);
 463         str << Token::RIGHT_PAREN << Token::NEWLINE;
 464
 465         // Statement executed if true
 466         if (!isBlockStatement(m_trueStatement))
 467         {
 468                 str << Token::INDENT_INC;
 469                 m_trueStatement->tokenize(state, str);
 470                 str << Token::INDENT_DEC;
 471         }
 472         else
 473                 m_trueStatement->tokenize(state, str);
 474
 475         if (m_falseStatement)
 476         {
 477                 str << Token::ELSE;
 478
 479                 if (isConditionalStatement(m_falseStatement))
 480                 {
 481                         m_falseStatement->tokenize(state, str);
 482                 }
 483                 else if (isBlockStatement(m_falseStatement))
 484                 {
 485                         str << Token::NEWLINE;
 486                         m_falseStatement->tokenize(state, str);
 487                 }
 488                 else
 489                 {
 490                         str << Token::NEWLINE << Token::INDENT_INC;
 491                         m_falseStatement->tokenize(state, str);
 492                         str << Token::INDENT_DEC;
 493                 }
 494         }
 495 }
 496
 497 void ConditionalStatement::execute (ExecutionContext& execCtx) const
 498 {
 499         // Evaluate condition
 500         m_condition->evaluate(execCtx);
 501
 502         ExecMaskStorage maskStorage; // Value might change when we are evaluating true block so we have to take a copy.
 503         ExecValueAccess trueMask        = maskStorage.getValue();
 504
 505         trueMask = m_condition->getValue().value();
 506
 507         // And mask, execute true statement and pop
 508         execCtx.andExecutionMask(trueMask);
 509         m_trueStatement->execute(execCtx);
 510         execCtx.popExecutionMask();
 511
 512         if (m_falseStatement)
 513         {
 514                 // Construct negated mask, execute false statement and pop
 515                 ExecMaskStorage tmp;
 516                 ExecValueAccess falseMask = tmp.getValue();
 517
 518                 for (int i = 0; i < EXEC_VEC_WIDTH; i++)
 519                         falseMask.asBool(i) = !trueMask.asBool(i);
 520
 521                 execCtx.andExecutionMask(falseMask);
 522                 m_falseStatement->execute(execCtx);
 523                 execCtx.popExecutionMask();
 524         }
 525 }
 526
 527 float ConditionalStatement::getWeight (const GeneratorState& state)
 528 {
 529         if (!state.getProgramParameters().useConditionals)
 530                 return 0.0f;
 531
 532         int availableLevels = state.getShaderParameters().maxStatementDepth - state.getStatementDepth();
 533         return (availableLevels > 1) ? 1.0f : 0.0f;
 534 }
 535
 536 AssignStatement::AssignStatement (const Variable* variable, Expression* value)
 537         : m_variable    (variable)
 538         , m_valueExpr   (value) // \note Takes ownership of value
 539 {
 540 }
 541
 542 AssignStatement::AssignStatement (GeneratorState& state, const Variable* variable, ConstValueRangeAccess valueRange)
 543         : m_variable    (variable)
 544         , m_valueExpr   (DE_NULL)
 545 {
 546         // Generate random value
 547         ExpressionGenerator generator(state);
 548         m_valueExpr = generator.generate(valueRange, 1);
 549 }
 550
 551 AssignStatement::~AssignStatement (void)
 552 {
 553         delete m_valueExpr;
 554 }
 555
 556 void AssignStatement::tokenize (GeneratorState& state, TokenStream& str) const
 557 {
 558         str << Token(m_variable->getName()) << Token::EQUAL;
 559         m_valueExpr->tokenize(state, str);
 560         str << Token::SEMICOLON << Token::NEWLINE;
 561 }
 562
 563 void AssignStatement::execute (ExecutionContext& execCtx) const
 564 {
 565         m_valueExpr->evaluate(execCtx);
 566         assignMasked(execCtx.getValue(m_variable), m_valueExpr->getValue(), execCtx.getExecutionMask());
 567 }
 568
 569 } // rsg