bundles/org.simantics.scl.compiler/src/org/simantics/scl/compiler/internal/elaboration/profiling/BranchPointInjector.java

   1 package org.simantics.scl.compiler.internal.elaboration.profiling;
   2
   3 import java.util.ArrayList;
   4
   5 import org.simantics.scl.compiler.elaboration.expressions.Case;
   6 import org.simantics.scl.compiler.elaboration.expressions.EApply;
   7 import org.simantics.scl.compiler.elaboration.expressions.EApplyType;
   8 import org.simantics.scl.compiler.elaboration.expressions.EAsPattern;
   9 import org.simantics.scl.compiler.elaboration.expressions.EBinary;
  10 import org.simantics.scl.compiler.elaboration.expressions.EBind;
  11 import org.simantics.scl.compiler.elaboration.expressions.EBlock;
  12 import org.simantics.scl.compiler.elaboration.expressions.EConstant;
  13 import org.simantics.scl.compiler.elaboration.expressions.ECoveringBranchPoint;
  14 import org.simantics.scl.compiler.elaboration.expressions.EEnforce;
  15 import org.simantics.scl.compiler.elaboration.expressions.EEntityTypeAnnotation;
  16 import org.simantics.scl.compiler.elaboration.expressions.EError;
  17 import org.simantics.scl.compiler.elaboration.expressions.EExternalConstant;
  18 import org.simantics.scl.compiler.elaboration.expressions.EFieldAccess;
  19 import org.simantics.scl.compiler.elaboration.expressions.EGetConstraint;
  20 import org.simantics.scl.compiler.elaboration.expressions.EIf;
  21 import org.simantics.scl.compiler.elaboration.expressions.EIntegerLiteral;
  22 import org.simantics.scl.compiler.elaboration.expressions.ELambda;
  23 import org.simantics.scl.compiler.elaboration.expressions.ELambdaType;
  24 import org.simantics.scl.compiler.elaboration.expressions.ELet;
  25 import org.simantics.scl.compiler.elaboration.expressions.EListComprehension;
  26 import org.simantics.scl.compiler.elaboration.expressions.EListLiteral;
  27 import org.simantics.scl.compiler.elaboration.expressions.ELiteral;
  28 import org.simantics.scl.compiler.elaboration.expressions.EMatch;
  29 import org.simantics.scl.compiler.elaboration.expressions.EPlaceholder;
  30 import org.simantics.scl.compiler.elaboration.expressions.EPreLet;
  31 import org.simantics.scl.compiler.elaboration.expressions.EPreRuleset;
  32 import org.simantics.scl.compiler.elaboration.expressions.ERange;
  33 import org.simantics.scl.compiler.elaboration.expressions.ERealLiteral;
  34 import org.simantics.scl.compiler.elaboration.expressions.ERecord;
  35 import org.simantics.scl.compiler.elaboration.expressions.ERuleset;
  36 import org.simantics.scl.compiler.elaboration.expressions.ESelect;
  37 import org.simantics.scl.compiler.elaboration.expressions.ESimpleLambda;
  38 import org.simantics.scl.compiler.elaboration.expressions.ESimpleLet;
  39 import org.simantics.scl.compiler.elaboration.expressions.EStringLiteral;
  40 import org.simantics.scl.compiler.elaboration.expressions.ETransformation;
  41 import org.simantics.scl.compiler.elaboration.expressions.ETypeAnnotation;
  42 import org.simantics.scl.compiler.elaboration.expressions.EVar;
  43 import org.simantics.scl.compiler.elaboration.expressions.EVariable;
  44 import org.simantics.scl.compiler.elaboration.expressions.EWhen;
  45 import org.simantics.scl.compiler.elaboration.expressions.Expression;
  46 import org.simantics.scl.compiler.elaboration.expressions.GuardedExpression;
  47 import org.simantics.scl.compiler.elaboration.expressions.GuardedExpressionGroup;
  48 import org.simantics.scl.compiler.elaboration.expressions.StandardExpressionTransformer;
  49 import org.simantics.scl.compiler.elaboration.expressions.block.BindStatement;
  50 import org.simantics.scl.compiler.elaboration.expressions.block.GuardStatement;
  51 import org.simantics.scl.compiler.elaboration.expressions.block.LetStatement;
  52 import org.simantics.scl.compiler.elaboration.expressions.block.RuleStatement;
  53 import org.simantics.scl.compiler.elaboration.expressions.list.ListAssignment;
  54 import org.simantics.scl.compiler.elaboration.expressions.list.ListGenerator;
  55 import org.simantics.scl.compiler.elaboration.expressions.list.ListGuard;
  56 import org.simantics.scl.compiler.elaboration.expressions.list.ListQualifier;
  57 import org.simantics.scl.compiler.elaboration.expressions.list.ListSeq;
  58 import org.simantics.scl.compiler.elaboration.expressions.list.ListThen;
  59 import org.simantics.scl.compiler.elaboration.query.QAlternative;
  60 import org.simantics.scl.compiler.elaboration.query.QAtom;
  61 import org.simantics.scl.compiler.elaboration.query.QConjunction;
  62 import org.simantics.scl.compiler.elaboration.query.QDisjunction;
  63 import org.simantics.scl.compiler.elaboration.query.QExists;
  64 import org.simantics.scl.compiler.elaboration.query.QIf;
  65 import org.simantics.scl.compiler.elaboration.query.QMapping;
  66 import org.simantics.scl.compiler.elaboration.query.QNegation;
  67 import org.simantics.scl.compiler.elaboration.query.Query;
  68 import org.simantics.scl.compiler.elaboration.query.pre.QPreBinds;
  69 import org.simantics.scl.compiler.elaboration.query.pre.QPreEquals;
  70 import org.simantics.scl.compiler.elaboration.query.pre.QPreExists;
  71 import org.simantics.scl.compiler.elaboration.query.pre.QPreGuard;
  72 import org.simantics.scl.runtime.profiling.BranchPoint;
  73
  74 public class BranchPointInjector extends StandardExpressionTransformer {
  75     public ArrayList<BranchPoint> currentBranchPoints = new ArrayList<BranchPoint>();
  76     int codeCounter = 0;
  77
  78     public Expression injectBranchPoint(Expression expression) {
  79         ArrayList<BranchPoint> oldBranchPoints = currentBranchPoints;
  80         currentBranchPoints = new ArrayList<BranchPoint>();
  81         int beginCodeCounter = codeCounter;
  82         expression = expression.accept(this);
  83         BranchPoint branchPoint = new BranchPoint(expression.location,
  84                 codeCounter - beginCodeCounter,
  85                 currentBranchPoints.isEmpty() ? BranchPoint.EMPTY_ARRAY
  86                         : currentBranchPoints.toArray(new BranchPoint[currentBranchPoints.size()]));
  87         oldBranchPoints.add(branchPoint);
  88         currentBranchPoints = oldBranchPoints;
  89         return new ECoveringBranchPoint(expression, branchPoint);
  90     }
  91
  92     @Override
  93     public Expression transform(ESimpleLambda expression) {
  94         ++codeCounter;
  95         expression.value = injectBranchPoint(expression.value);
  96         return expression;
  97     }
  98
  99     @Override
 100     public Expression transform(ELambda expression) {
 101         ++codeCounter;
 102         for(Case case_ : expression.cases)
 103             case_.value = injectBranchPoint(case_.value);
 104         return expression;
 105     }
 106
 107     @Override
 108     public Expression transform(EMatch expression) {
 109         ++codeCounter;
 110         for(int i=0;i<expression.scrutinee.length;++i)
 111             expression.scrutinee[i] = expression.scrutinee[i].accept(this);
 112         for(Case case_ : expression.cases)
 113             case_.value = injectBranchPoint(case_.value);
 114         return expression;
 115     }
 116
 117     @Override
 118     public Expression transform(EIf expression) {
 119         ++codeCounter;
 120         expression.condition = expression.condition.accept(this);
 121         expression.then_ = injectBranchPoint(expression.then_);
 122         expression.else_ = injectBranchPoint(expression.else_);
 123         return expression;
 124     }
 125
 126     @Override
 127     public Expression transform(EBind expression) {
 128         ++codeCounter;
 129         expression.pattern = expression.pattern.accept(this);
 130         expression.value = expression.value.accept(this);
 131         expression.in = injectBranchPoint(expression.in);
 132         return expression;
 133     }
 134
 135     @Override
 136     public Expression transform(EListComprehension expression) {
 137         ++codeCounter;
 138         expression.head = injectBranchPoint(expression.head);
 139         expression.qualifier =  expression.qualifier.accept(this);
 140         return expression;
 141     }
 142
 143     @Override
 144     public Expression transform(EWhen expression) {
 145         ++codeCounter;
 146         expression.query = expression.query.accept(this);
 147         expression.action = injectBranchPoint(expression.action);
 148         return expression;
 149     }
 150
 151     @Override
 152     public Expression transform(GuardedExpressionGroup expression) {
 153         ++codeCounter;
 154         for(GuardedExpression ge : expression.expressions) {
 155             for(int i=0;i<ge.guards.length;++i)
 156                 ge.guards[i] = ge.guards[i].accept(this);
 157             ge.value = injectBranchPoint(ge.value);
 158         }
 159         return expression;
 160     }
 161
 162     @Override
 163     public Expression transform(EApply expression) {
 164         ++codeCounter;
 165         return super.transform(expression);
 166     }
 167
 168     @Override
 169     public Expression transform(EApplyType expression) {
 170         ++codeCounter;
 171         return super.transform(expression);
 172     }
 173
 174     @Override
 175     public Expression transform(EAsPattern expression) {
 176         ++codeCounter;
 177         return super.transform(expression);
 178     }
 179
 180     @Override
 181     public Expression transform(EBinary expression) {
 182         ++codeCounter;
 183         return super.transform(expression);
 184     }
 185
 186     @Override
 187     public Expression transform(EBlock expression) {
 188         ++codeCounter;
 189         return super.transform(expression);
 190     }
 191
 192     @Override
 193     public Expression transform(EConstant expression) {
 194         ++codeCounter;
 195         return super.transform(expression);
 196     }
 197
 198     @Override
 199     public Expression transform(ECoveringBranchPoint expression) {
 200         ++codeCounter;
 201         return super.transform(expression);
 202     }
 203
 204     @Override
 205     public Expression transform(EEnforce expression) {
 206         ++codeCounter;
 207         return super.transform(expression);
 208     }
 209
 210     @Override
 211     public Expression transform(EEntityTypeAnnotation expression) {
 212         ++codeCounter;
 213         return super.transform(expression);
 214     }
 215
 216     @Override
 217     public Expression transform(EError expression) {
 218         ++codeCounter;
 219         return super.transform(expression);
 220     }
 221
 222     @Override
 223     public Expression transform(EExternalConstant expression) {
 224         ++codeCounter;
 225         return super.transform(expression);
 226     }
 227
 228     @Override
 229     public Expression transform(EFieldAccess expression) {
 230         ++codeCounter;
 231         return super.transform(expression);
 232     }
 233
 234     @Override
 235     public Expression transform(EGetConstraint expression) {
 236         ++codeCounter;
 237         return super.transform(expression);
 238     }
 239
 240     @Override
 241     public Expression transform(EIntegerLiteral expression) {
 242         ++codeCounter;
 243         return super.transform(expression);
 244     }
 245
 246     @Override
 247     public Expression transform(ELambdaType expression) {
 248         ++codeCounter;
 249         return super.transform(expression);
 250     }
 251
 252     @Override
 253     public Expression transform(ELet expression) {
 254         ++codeCounter;
 255         return super.transform(expression);
 256     }
 257
 258     @Override
 259     public Expression transform(EListLiteral expression) {
 260         ++codeCounter;
 261         return super.transform(expression);
 262     }
 263
 264     @Override
 265     public Expression transform(ELiteral expression) {
 266         ++codeCounter;
 267         return super.transform(expression);
 268     }
 269
 270     @Override
 271     public Expression transform(EPlaceholder expression) {
 272         ++codeCounter;
 273         return super.transform(expression);
 274     }
 275
 276     @Override
 277     public Expression transform(EPreLet expression) {
 278         ++codeCounter;
 279         return super.transform(expression);
 280     }
 281
 282     @Override
 283     public Expression transform(EPreRuleset expression) {
 284         ++codeCounter;
 285         return super.transform(expression);
 286     }
 287
 288     @Override
 289     public Expression transform(ERange expression) {
 290         ++codeCounter;
 291         return super.transform(expression);
 292     }
 293
 294     @Override
 295     public Expression transform(ERealLiteral expression) {
 296         ++codeCounter;
 297         return super.transform(expression);
 298     }
 299
 300     @Override
 301     public Expression transform(ERecord expression) {
 302         ++codeCounter;
 303         return super.transform(expression);
 304     }
 305
 306     @Override
 307     public Expression transform(ERuleset expression) {
 308         ++codeCounter;
 309         return super.transform(expression);
 310     }
 311
 312     @Override
 313     public Expression transform(ESelect expression) {
 314         ++codeCounter;
 315         return super.transform(expression);
 316     }
 317
 318     @Override
 319     public Expression transform(ESimpleLet expression) {
 320         ++codeCounter;
 321         return super.transform(expression);
 322     }
 323
 324     @Override
 325     public Expression transform(EStringLiteral expression) {
 326         ++codeCounter;
 327         return super.transform(expression);
 328     }
 329
 330     @Override
 331     public Expression transform(ETransformation expression) {
 332         ++codeCounter;
 333         return super.transform(expression);
 334     }
 335
 336     @Override
 337     public Expression transform(ETypeAnnotation expression) {
 338         ++codeCounter;
 339         return super.transform(expression);
 340     }
 341
 342     @Override
 343     public Expression transform(EVar expression) {
 344         ++codeCounter;
 345         return super.transform(expression);
 346     }
 347
 348     @Override
 349     public Expression transform(EVariable expression) {
 350         ++codeCounter;
 351         return super.transform(expression);
 352     }
 353
 354     @Override
 355     public ListQualifier transform(ListAssignment qualifier) {
 356         ++codeCounter;
 357         return super.transform(qualifier);
 358     }
 359
 360     @Override
 361     public ListQualifier transform(ListGenerator qualifier) {
 362         ++codeCounter;
 363         return super.transform(qualifier);
 364     }
 365
 366     @Override
 367     public ListQualifier transform(ListGuard qualifier) {
 368         ++codeCounter;
 369         return super.transform(qualifier);
 370     }
 371
 372     @Override
 373     public ListQualifier transform(ListSeq qualifier) {
 374         ++codeCounter;
 375         return super.transform(qualifier);
 376     }
 377
 378     @Override
 379     public ListQualifier transform(ListThen qualifier) {
 380         ++codeCounter;
 381         return super.transform(qualifier);
 382     }
 383
 384     @Override
 385     public Query transform(QAlternative query) {
 386         ++codeCounter;
 387         return super.transform(query);
 388     }
 389
 390     @Override
 391     public Query transform(QAtom query) {
 392         ++codeCounter;
 393         return super.transform(query);
 394     }
 395
 396     @Override
 397     public Query transform(QConjunction query) {
 398         ++codeCounter;
 399         return super.transform(query);
 400     }
 401
 402     @Override
 403     public Query transform(QDisjunction query) {
 404         ++codeCounter;
 405         return super.transform(query);
 406     }
 407
 408     @Override
 409     public Query transform(QExists query) {
 410         ++codeCounter;
 411         return super.transform(query);
 412     }
 413
 414     @Override
 415     public Query transform(QIf query) {
 416         ++codeCounter;
 417         return super.transform(query);
 418     }
 419
 420     @Override
 421     public Query transform(QMapping query) {
 422         ++codeCounter;
 423         return super.transform(query);
 424     }
 425
 426     @Override
 427     public Query transform(QNegation query) {
 428         ++codeCounter;
 429         return super.transform(query);
 430     }
 431
 432     @Override
 433     public Query transform(QPreBinds query) {
 434         ++codeCounter;
 435         return super.transform(query);
 436     }
 437
 438     @Override
 439     public Query transform(QPreEquals query) {
 440         ++codeCounter;
 441         return super.transform(query);
 442     }
 443
 444     @Override
 445     public Query transform(QPreExists query) {
 446         ++codeCounter;
 447         return super.transform(query);
 448     }
 449
 450     @Override
 451     public Query transform(QPreGuard query) {
 452         ++codeCounter;
 453         return super.transform(query);
 454     }
 455
 456     public BranchPoint[] getAndClearBranchPoints() {
 457         BranchPoint[] result = currentBranchPoints.toArray(new BranchPoint[currentBranchPoints.size()]);
 458         currentBranchPoints.clear();
 459         return result;
 460     }
 461
 462     @Override
 463     public void visit(BindStatement statement) {
 464         ++codeCounter;
 465         super.visit(statement);
 466     }
 467
 468     @Override
 469     public void visit(GuardStatement statement) {
 470         ++codeCounter;
 471         super.visit(statement);
 472     }
 473
 474     @Override
 475     public void visit(LetStatement statement) {
 476         ++codeCounter;
 477         if(statement.pattern.isFunctionDefinitionLhs())
 478             statement.value = injectBranchPoint(statement.value);
 479         else
 480             super.visit(statement);
 481     }
 482
 483     @Override
 484     public void visit(RuleStatement statement) {
 485         ++codeCounter;
 486         super.visit(statement);
 487     }
 488
 489 }