org.eclipse.linuxtools.tmf.core/src/org/eclipse/linuxtools/internal/tmf/core/statesystem/StateSystem.java

   1 /*******************************************************************************
   2  * Copyright (c) 2012, 2013 Ericsson
   3  * Copyright (c) 2010, 2011 École Polytechnique de Montréal
   4  * Copyright (c) 2010, 2011 Alexandre Montplaisir <alexandre.montplaisir@gmail.com>
   5  *
   6  * All rights reserved. This program and the accompanying materials are
   7  * made available under the terms of the Eclipse Public License v1.0 which
   8  * accompanies this distribution, and is available at
   9  * http://www.eclipse.org/legal/epl-v10.html
  10  *
  11  *******************************************************************************/
  12
  13 package org.eclipse.linuxtools.internal.tmf.core.statesystem;
  14
  15 import java.io.File;
  16 import java.io.IOException;
  17 import java.io.PrintWriter;
  18 import java.util.ArrayList;
  19 import java.util.LinkedList;
  20 import java.util.List;
  21 import java.util.concurrent.CountDownLatch;
  22
  23 import org.eclipse.core.runtime.IProgressMonitor;
  24 import org.eclipse.core.runtime.NullProgressMonitor;
  25 import org.eclipse.linuxtools.internal.tmf.core.Activator;
  26 import org.eclipse.linuxtools.internal.tmf.core.statesystem.backends.IStateHistoryBackend;
  27 import org.eclipse.linuxtools.tmf.core.exceptions.AttributeNotFoundException;
  28 import org.eclipse.linuxtools.tmf.core.exceptions.StateSystemDisposedException;
  29 import org.eclipse.linuxtools.tmf.core.exceptions.StateValueTypeException;
  30 import org.eclipse.linuxtools.tmf.core.exceptions.TimeRangeException;
  31 import org.eclipse.linuxtools.tmf.core.interval.ITmfStateInterval;
  32 import org.eclipse.linuxtools.tmf.core.interval.TmfStateInterval;
  33 import org.eclipse.linuxtools.tmf.core.statesystem.ITmfStateSystemBuilder;
  34 import org.eclipse.linuxtools.tmf.core.statevalue.ITmfStateValue;
  35 import org.eclipse.linuxtools.tmf.core.statevalue.TmfStateValue;
  36
  37 /**
  38  * This is the core class of the Generic State System. It contains all the
  39  * methods to build and query a state history. It's exposed externally through
  40  * the IStateSystemQuerier and IStateSystemBuilder interfaces, depending if the
  41  * user needs read-only access or read-write access.
  42  *
  43  * When building, DON'T FORGET to call .closeHistory() when you are done
  44  * inserting intervals, or the storage backend will have no way of knowing it
  45  * can close and write itself to disk, and its thread will keep running.
  46  *
  47  * @author alexmont
  48  *
  49  */
  50 public class StateSystem implements ITmfStateSystemBuilder {
  51
  52     /* References to the inner structures */
  53     private final AttributeTree attributeTree;
  54     private final TransientState transState;
  55     private final IStateHistoryBackend backend;
  56
  57     /* Latch tracking if the state history is done building or not */
  58     private final CountDownLatch finishedLatch = new CountDownLatch(1);
  59
  60     private boolean buildCancelled = false;
  61     private boolean isDisposed = false;
  62
  63     /**
  64      * New-file constructor. For when you build a state system with a new file,
  65      * or if the back-end does not require a file on disk.
  66      *
  67      * @param backend
  68      *            Back-end plugin to use
  69      */
  70     public StateSystem(IStateHistoryBackend backend) {
  71         this.backend = backend;
  72         this.transState = new TransientState(backend);
  73         this.attributeTree = new AttributeTree(this);
  74     }
  75
  76     /**
  77      * General constructor
  78      *
  79      * @param backend
  80      *            The "state history storage" back-end to use.
  81      * @param newFile
  82      *            Put true if this is a new history started from scratch. It is
  83      *            used to tell the state system where to get its attribute tree.
  84      * @throws IOException
  85      *             If there was a problem creating the new history file
  86      */
  87     public StateSystem(IStateHistoryBackend backend, boolean newFile)
  88             throws IOException {
  89         this.backend = backend;
  90         this.transState = new TransientState(backend);
  91
  92         if (newFile) {
  93             attributeTree = new AttributeTree(this);
  94         } else {
  95             /* We're opening an existing file */
  96             this.attributeTree = new AttributeTree(this, backend.supplyAttributeTreeReader());
  97             transState.setInactive();
  98             finishedLatch.countDown(); /* The history is already built */
  99         }
 100     }
 101
 102     @Override
 103     public boolean waitUntilBuilt() {
 104         try {
 105             finishedLatch.await();
 106         } catch (InterruptedException e) {
 107             e.printStackTrace();
 108         }
 109         return !buildCancelled;
 110     }
 111
 112     @Override
 113     public synchronized void dispose() {
 114         isDisposed = true;
 115         if (transState.isActive()) {
 116             transState.setInactive();
 117             buildCancelled = true;
 118         }
 119         backend.dispose();
 120     }
 121
 122     //--------------------------------------------------------------------------
 123     //        General methods related to the attribute tree
 124     //--------------------------------------------------------------------------
 125
 126     /**
 127      * Method used by the attribute tree when creating new attributes, to keep
 128      * the attribute count in the transient state in sync.
 129      */
 130     void addEmptyAttribute() {
 131         transState.addEmptyEntry();
 132     }
 133
 134     @Override
 135     public int getNbAttributes() {
 136         return attributeTree.getNbAttributes();
 137     }
 138
 139     @Override
 140     public boolean isLastAttribute(int quark) {
 141         return (quark == getNbAttributes() - 1) ? true : false;
 142     }
 143
 144     @Override
 145     public String getAttributeName(int attributeQuark) {
 146         return attributeTree.getAttributeName(attributeQuark);
 147     }
 148
 149     @Override
 150     public String getFullAttributePath(int attributeQuark) {
 151         return attributeTree.getFullAttributeName(attributeQuark);
 152     }
 153
 154     //--------------------------------------------------------------------------
 155     //        Methods related to the storage backend
 156     //--------------------------------------------------------------------------
 157
 158     @Override
 159     public long getStartTime() {
 160         return backend.getStartTime();
 161     }
 162
 163     @Override
 164     public long getCurrentEndTime() {
 165         return backend.getEndTime();
 166     }
 167
 168     @Override
 169     public void closeHistory(long endTime) throws TimeRangeException {
 170         File attributeTreeFile;
 171         long attributeTreeFilePos;
 172         long realEndTime = endTime;
 173
 174         if (realEndTime < backend.getEndTime()) {
 175             /*
 176              * This can happen (empty nodes pushing the border further, etc.)
 177              * but shouldn't be too big of a deal.
 178              */
 179             realEndTime = backend.getEndTime();
 180         }
 181         transState.closeTransientState(realEndTime);
 182         backend.finishedBuilding(realEndTime);
 183
 184         attributeTreeFile = backend.supplyAttributeTreeWriterFile();
 185         attributeTreeFilePos = backend.supplyAttributeTreeWriterFilePosition();
 186         if (attributeTreeFile != null) {
 187             /*
 188              * If null was returned, we simply won't save the attribute tree,
 189              * too bad!
 190              */
 191             attributeTree.writeSelf(attributeTreeFile, attributeTreeFilePos);
 192         }
 193         finishedLatch.countDown(); /* Mark the history as finished building */
 194     }
 195
 196     //--------------------------------------------------------------------------
 197     //        Quark-retrieving methods
 198     //--------------------------------------------------------------------------
 199
 200     @Override
 201     public int getQuarkAbsolute(String... attribute)
 202             throws AttributeNotFoundException {
 203         return attributeTree.getQuarkDontAdd(-1, attribute);
 204     }
 205
 206     @Override
 207     public int getQuarkAbsoluteAndAdd(String... attribute) {
 208         return attributeTree.getQuarkAndAdd(-1, attribute);
 209     }
 210
 211     @Override
 212     public int getQuarkRelative(int startingNodeQuark, String... subPath)
 213             throws AttributeNotFoundException {
 214         return attributeTree.getQuarkDontAdd(startingNodeQuark, subPath);
 215     }
 216
 217     @Override
 218     public int getQuarkRelativeAndAdd(int startingNodeQuark, String... subPath) {
 219         return attributeTree.getQuarkAndAdd(startingNodeQuark, subPath);
 220     }
 221
 222     @Override
 223     public List<Integer> getSubAttributes(int quark, boolean recursive)
 224             throws AttributeNotFoundException {
 225         return attributeTree.getSubAttributes(quark, recursive);
 226     }
 227
 228     @Override
 229     public List<Integer> getQuarks(String... pattern) {
 230         List<Integer> quarks = new LinkedList<Integer>();
 231         List<String> prefix = new LinkedList<String>();
 232         List<String> suffix = new LinkedList<String>();
 233         boolean split = false;
 234         String[] prefixStr;
 235         String[] suffixStr;
 236         List<Integer> directChildren;
 237         int startingAttribute;
 238
 239         /* Fill the "prefix" and "suffix" parts of the pattern around the '*' */
 240         for (String entry : pattern) {
 241             if (entry.equals("*")) { //$NON-NLS-1$
 242                 if (split) {
 243                     /*
 244                      * Split was already true? This means there was more than
 245                      * one wildcard. This is not supported, return an empty
 246                      * list.
 247                      */
 248                     return quarks;
 249                 }
 250                 split = true;
 251                 continue;
 252             }
 253
 254             if (split) {
 255                 suffix.add(entry);
 256             } else {
 257                 prefix.add(entry);
 258             }
 259         }
 260         prefixStr = prefix.toArray(new String[prefix.size()]);
 261         suffixStr = suffix.toArray(new String[suffix.size()]);
 262
 263         /*
 264          * If there was no wildcard, we'll only return the one matching
 265          * attribute, if there is one.
 266          */
 267         if (split == false) {
 268             int quark;
 269             try {
 270                 quark = getQuarkAbsolute(prefixStr);
 271             } catch (AttributeNotFoundException e) {
 272                 /* It's fine, we'll just return the empty List */
 273                 return quarks;
 274             }
 275             quarks.add(quark);
 276             return quarks;
 277         }
 278
 279         try {
 280             if (prefix.size() == 0) {
 281                 /*
 282                  * If 'prefix' is empty, this means the wildcard was the first
 283                  * element. Look for the root node's sub-attributes.
 284                  */
 285                 startingAttribute = -1;
 286             } else {
 287                 startingAttribute = getQuarkAbsolute(prefixStr);
 288             }
 289             directChildren = attributeTree.getSubAttributes(startingAttribute,
 290                     false);
 291         } catch (AttributeNotFoundException e) {
 292             /* That attribute path did not exist, return the empty array */
 293             return quarks;
 294         }
 295
 296         /*
 297          * Iterate of all the sub-attributes, and only keep those who match the
 298          * 'suffix' part of the initial pattern.
 299          */
 300         for (int childQuark : directChildren) {
 301             int matchingQuark;
 302             try {
 303                 matchingQuark = getQuarkRelative(childQuark, suffixStr);
 304             } catch (AttributeNotFoundException e) {
 305                 continue;
 306             }
 307             quarks.add(matchingQuark);
 308         }
 309
 310         return quarks;
 311     }
 312
 313     //--------------------------------------------------------------------------
 314     //        Methods related to insertions in the history
 315     //--------------------------------------------------------------------------
 316
 317     @Override
 318     public void modifyAttribute(long t, ITmfStateValue value, int attributeQuark)
 319             throws TimeRangeException, AttributeNotFoundException,
 320             StateValueTypeException {
 321         transState.processStateChange(t, value, attributeQuark);
 322     }
 323
 324     @Override
 325     public void incrementAttribute(long t, int attributeQuark)
 326             throws StateValueTypeException, TimeRangeException,
 327             AttributeNotFoundException {
 328         int prevValue = queryOngoingState(attributeQuark).unboxInt();
 329         if (prevValue == -1) {
 330             /* if the attribute was previously null, start counting at 0 */
 331             prevValue = 0;
 332         }
 333         modifyAttribute(t, TmfStateValue.newValueInt(prevValue + 1),
 334                 attributeQuark);
 335     }
 336
 337     @Override
 338     public void pushAttribute(long t, ITmfStateValue value, int attributeQuark)
 339             throws TimeRangeException, AttributeNotFoundException,
 340             StateValueTypeException {
 341         Integer stackDepth = 0;
 342         int subAttributeQuark;
 343         ITmfStateValue previousSV = transState.getOngoingStateValue(attributeQuark);
 344
 345         if (previousSV.isNull()) {
 346             /*
 347              * If the StateValue was null, this means this is the first time we
 348              * use this attribute. Leave stackDepth at 0.
 349              */
 350         } else if (previousSV.getType() == 0) {
 351             /* Previous value was an integer, all is good, use it */
 352             stackDepth = previousSV.unboxInt();
 353         } else {
 354             /* Previous state of this attribute was another type? Not good! */
 355             throw new StateValueTypeException();
 356         }
 357
 358         if (stackDepth >= 10) {
 359             /*
 360              * Limit stackDepth to 10, to avoid having Attribute Trees grow out
 361              * of control due to buggy insertions
 362              */
 363             String message = "Stack limit reached, not pushing"; //$NON-NLS-1$
 364             throw new AttributeNotFoundException(message);
 365         }
 366
 367         stackDepth++;
 368         subAttributeQuark = getQuarkRelativeAndAdd(attributeQuark, stackDepth.toString());
 369
 370         modifyAttribute(t, TmfStateValue.newValueInt(stackDepth), attributeQuark);
 371         modifyAttribute(t, value, subAttributeQuark);
 372     }
 373
 374     @Override
 375     public ITmfStateValue popAttribute(long t, int attributeQuark)
 376             throws AttributeNotFoundException, TimeRangeException,
 377             StateValueTypeException {
 378         /* These are the state values of the stack-attribute itself */
 379         ITmfStateValue previousSV = queryOngoingState(attributeQuark);
 380
 381         if (previousSV.isNull()) {
 382             /*
 383              * Trying to pop an empty stack. This often happens at the start of
 384              * traces, for example when we see a syscall_exit, without having
 385              * the corresponding syscall_entry in the trace. Just ignore
 386              * silently.
 387              */
 388             return null;
 389         }
 390         if (previousSV.getType() != ITmfStateValue.TYPE_INTEGER) {
 391             /*
 392              * The existing value was a string, this doesn't look like a valid
 393              * stack attribute.
 394              */
 395             throw new StateValueTypeException();
 396         }
 397
 398         Integer stackDepth = previousSV.unboxInt();
 399
 400         if (stackDepth <= 0) {
 401             /* This on the other hand should not happen... */
 402             /* the case where == -1 was handled previously by .isNull() */
 403             String message = "A top-level stack attribute cannot " + //$NON-NLS-1$
 404                     "have a value of 0 or less (except -1/null)."; //$NON-NLS-1$
 405             throw new StateValueTypeException(message);
 406         }
 407
 408         /* The attribute should already exist at this point */
 409         int subAttributeQuark = getQuarkRelative(attributeQuark, stackDepth.toString());
 410         ITmfStateValue poppedValue = queryOngoingState(subAttributeQuark);
 411
 412         /* Update the state value of the stack-attribute */
 413         ITmfStateValue nextSV;
 414         if (--stackDepth == 0 ) {
 415             /* Jump over "0" and store -1 (a null state value) */
 416             nextSV = TmfStateValue.nullValue();
 417         } else {
 418             nextSV = TmfStateValue.newValueInt(stackDepth);
 419         }
 420         modifyAttribute(t, nextSV, attributeQuark);
 421
 422         /* Delete the sub-attribute that contained the user's state value */
 423         removeAttribute(t, subAttributeQuark);
 424
 425         return poppedValue;
 426     }
 427
 428     @Override
 429     public void removeAttribute(long t, int attributeQuark)
 430             throws TimeRangeException, AttributeNotFoundException {
 431         assert (attributeQuark >= 0);
 432         List<Integer> childAttributes;
 433
 434         /*
 435          * "Nullify our children first, recursively. We pass 'false' because we
 436          * handle the recursion ourselves.
 437          */
 438         childAttributes = attributeTree.getSubAttributes(attributeQuark, false);
 439         for (Integer childNodeQuark : childAttributes) {
 440             assert (attributeQuark != childNodeQuark);
 441             removeAttribute(t, childNodeQuark);
 442         }
 443         /* Nullify ourselves */
 444         try {
 445             transState.processStateChange(t, TmfStateValue.nullValue(),
 446                     attributeQuark);
 447         } catch (StateValueTypeException e) {
 448             /*
 449              * Will not happen since we're inserting null values only, but poor
 450              * compiler has no way of knowing this...
 451              */
 452             e.printStackTrace();
 453         }
 454     }
 455
 456     //--------------------------------------------------------------------------
 457     //        "Current" query/update methods
 458     //--------------------------------------------------------------------------
 459
 460     @Override
 461     public ITmfStateValue queryOngoingState(int attributeQuark)
 462             throws AttributeNotFoundException {
 463         return transState.getOngoingStateValue(attributeQuark);
 464     }
 465
 466     @Override
 467     public void updateOngoingState(ITmfStateValue newValue, int attributeQuark)
 468             throws AttributeNotFoundException {
 469         transState.changeOngoingStateValue(attributeQuark, newValue);
 470     }
 471
 472
 473
 474     //--------------------------------------------------------------------------
 475     //        Regular query methods (sent to the back-end)
 476     //--------------------------------------------------------------------------
 477
 478     @Override
 479     public synchronized List<ITmfStateInterval> queryFullState(long t)
 480             throws TimeRangeException, StateSystemDisposedException {
 481         if (isDisposed) {
 482             throw new StateSystemDisposedException();
 483         }
 484
 485         List<ITmfStateInterval> stateInfo = new ArrayList<ITmfStateInterval>(
 486                 attributeTree.getNbAttributes());
 487
 488         /* Bring the size of the array to the current number of attributes */
 489         for (int i = 0; i < attributeTree.getNbAttributes(); i++) {
 490             stateInfo.add(null);
 491         }
 492
 493         /* Query the storage backend */
 494         backend.doQuery(stateInfo, t);
 495
 496         /*
 497          * If we are currently building the history, also query the "ongoing"
 498          * states for stuff that might not yet be written to the history.
 499          */
 500         if (transState.isActive()) {
 501             transState.doQuery(stateInfo, t);
 502         }
 503
 504         /*
 505          * We should have previously inserted an interval for every attribute.
 506          * If we do happen do see a 'null' object here, just replace it with a a
 507          * dummy internal with a null value, to avoid NPE's further up.
 508          */
 509         for (int i = 0; i < stateInfo.size(); i++) {
 510             if (stateInfo.get(i) == null) {
 511                 //logMissingInterval(i, t);
 512                 stateInfo.set(i, new TmfStateInterval(t, t, i, TmfStateValue.nullValue()));
 513             }
 514         }
 515         return stateInfo;
 516     }
 517
 518     @Override
 519     public ITmfStateInterval querySingleState(long t, int attributeQuark)
 520             throws AttributeNotFoundException, TimeRangeException,
 521             StateSystemDisposedException {
 522         if (isDisposed) {
 523             throw new StateSystemDisposedException();
 524         }
 525
 526         ITmfStateInterval ret;
 527         if (transState.hasInfoAboutStateOf(t, attributeQuark)) {
 528             ret = transState.getOngoingInterval(attributeQuark);
 529         } else {
 530             ret = backend.doSingularQuery(t, attributeQuark);
 531         }
 532
 533         /*
 534          * Return a fake interval if we could not find anything in the history.
 535          * We do NOT want to return 'null' here.
 536          */
 537         if (ret == null) {
 538             //logMissingInterval(attributeQuark, t);
 539             return new TmfStateInterval(t, this.getCurrentEndTime(),
 540                     attributeQuark, TmfStateValue.nullValue());
 541         }
 542         return ret;
 543     }
 544
 545     @Override
 546     public ITmfStateInterval querySingleStackTop(long t, int stackAttributeQuark)
 547             throws StateValueTypeException, AttributeNotFoundException,
 548             TimeRangeException, StateSystemDisposedException {
 549         Integer curStackDepth = querySingleState(t, stackAttributeQuark).getStateValue().unboxInt();
 550
 551         if (curStackDepth == -1) {
 552             /* There is nothing stored in this stack at this moment */
 553             return null;
 554         } else if (curStackDepth < -1 || curStackDepth == 0) {
 555             /*
 556              * This attribute is an integer attribute, but it doesn't seem like
 557              * it's used as a stack-attribute...
 558              */
 559             throw new StateValueTypeException();
 560         }
 561
 562         int subAttribQuark = getQuarkRelative(stackAttributeQuark, curStackDepth.toString());
 563         ITmfStateInterval ret = querySingleState(t, subAttribQuark);
 564         return ret;
 565     }
 566
 567     @Override
 568     public List<ITmfStateInterval> queryHistoryRange(int attributeQuark,
 569             long t1, long t2) throws TimeRangeException,
 570             AttributeNotFoundException, StateSystemDisposedException {
 571         if (isDisposed) {
 572             throw new StateSystemDisposedException();
 573         }
 574
 575         List<ITmfStateInterval> intervals;
 576         ITmfStateInterval currentInterval;
 577         long ts, tEnd;
 578
 579         /* Make sure the time range makes sense */
 580         if (t2 <= t1) {
 581             throw new TimeRangeException();
 582         }
 583
 584         /* Set the actual, valid end time of the range query */
 585         if (t2 > this.getCurrentEndTime()) {
 586             tEnd = this.getCurrentEndTime();
 587         } else {
 588             tEnd = t2;
 589         }
 590
 591         /* Get the initial state at time T1 */
 592         intervals = new ArrayList<ITmfStateInterval>();
 593         currentInterval = querySingleState(t1, attributeQuark);
 594         intervals.add(currentInterval);
 595
 596         /* Get the following state changes */
 597         ts = currentInterval.getEndTime();
 598         while (ts != -1 && ts < tEnd) {
 599             ts++; /* To "jump over" to the next state in the history */
 600             currentInterval = querySingleState(ts, attributeQuark);
 601             intervals.add(currentInterval);
 602             ts = currentInterval.getEndTime();
 603         }
 604         return intervals;
 605     }
 606
 607     @Override
 608     public List<ITmfStateInterval> queryHistoryRange(int attributeQuark,
 609             long t1, long t2, long resolution, IProgressMonitor monitor)
 610             throws TimeRangeException, AttributeNotFoundException,
 611             StateSystemDisposedException {
 612         if (isDisposed) {
 613             throw new StateSystemDisposedException();
 614         }
 615
 616         List<ITmfStateInterval> intervals;
 617         ITmfStateInterval currentInterval;
 618         long ts, tEnd;
 619
 620         IProgressMonitor mon = monitor;
 621         if (mon == null) {
 622             mon = new NullProgressMonitor();
 623         }
 624
 625         /* Make sure the time range makes sense */
 626         if (t2 < t1 || resolution <= 0) {
 627             throw new TimeRangeException();
 628         }
 629
 630         /* Set the actual, valid end time of the range query */
 631         if (t2 > this.getCurrentEndTime()) {
 632             tEnd = this.getCurrentEndTime();
 633         } else {
 634             tEnd = t2;
 635         }
 636
 637         /* Get the initial state at time T1 */
 638         intervals = new ArrayList<ITmfStateInterval>();
 639         currentInterval = querySingleState(t1, attributeQuark);
 640         intervals.add(currentInterval);
 641
 642         /*
 643          * Iterate over the "resolution points". We skip unneeded queries in the
 644          * case the current interval is longer than the resolution.
 645          */
 646         for (ts = t1; (currentInterval.getEndTime() != -1) && (ts < tEnd);
 647                 ts += resolution) {
 648             if (mon.isCanceled()) {
 649                 return intervals;
 650             }
 651             if (ts <= currentInterval.getEndTime()) {
 652                 continue;
 653             }
 654             currentInterval = querySingleState(ts, attributeQuark);
 655             intervals.add(currentInterval);
 656         }
 657
 658         /* Add the interval at t2, if it wasn't included already. */
 659         if (currentInterval.getEndTime() < tEnd) {
 660             currentInterval = querySingleState(tEnd, attributeQuark);
 661             intervals.add(currentInterval);
 662         }
 663         return intervals;
 664     }
 665
 666     //--------------------------------------------------------------------------
 667     //        Debug methods
 668     //--------------------------------------------------------------------------
 669
 670     static void logMissingInterval(int attribute, long timestamp) {
 671         Activator.logInfo("No data found in history for attribute " + //$NON-NLS-1$
 672                 attribute + " at time " + timestamp + //$NON-NLS-1$
 673                 ", returning dummy interval"); //$NON-NLS-1$
 674     }
 675
 676     /**
 677      * Print out the contents of the inner structures.
 678      *
 679      * @param writer
 680      *            The PrintWriter in which to print the output
 681      */
 682     public void debugPrint(PrintWriter writer) {
 683         attributeTree.debugPrint(writer);
 684         transState.debugPrint(writer);
 685         backend.debugPrint(writer);
 686     }
 687
 688 }