/*
 *  This file is part of the Jikes RVM project (http://jikesrvm.org).
 *
 *  This file is licensed to You under the Eclipse Public License (EPL);
 *  You may not use this file except in compliance with the License. You
 *  may obtain a copy of the License at
 *
 *      http://www.opensource.org/licenses/eclipse-1.0.php
 *
 *  See the COPYRIGHT.txt file distributed with this work for information
 *  regarding copyright ownership.
 */
package org.mmtk.utility.deque;

import org.mmtk.utility.Log;
import org.mmtk.utility.TracingConstants;
import org.mmtk.vm.VM;
import org.mmtk.utility.Constants;

import org.vmmagic.pragma.*;
import org.vmmagic.unboxed.*;

/**
 * This supports <i>unsynchronized</i> enqueuing and dequeuing of tracing data
 * and bulk processing of the buffer.
 */
@Uninterruptible public class TraceBuffer extends LocalQueue
  implements Constants, TracingConstants {

  /***********************************************************************
   *
   * Class based constants
   */
  private static final Word TRACE_NEW_RECORD = Word.fromIntSignExtend(3);
  private static final Word TRACE_ALLOC_SIZE = Word.fromIntSignExtend(5);
//  private static final Word TRACE_ALLOC_NAME = Word.fromIntSignExtend(6);
  private static final Word TRACE_ALLOC_FP = Word.fromIntSignExtend(7);
  private static final Word TRACE_ALLOC_THREAD = Word.fromIntSignExtend(9);
  private static final Word TRACE_TIB_VALUE = Word.fromIntSignExtend(10);
  private static final Word TRACE_DEATH_TIME = Word.fromIntSignExtend(11);
  private static final Word TRACE_FIELD_TARGET = Word.fromIntSignExtend(12);
  private static final Word TRACE_ARRAY_TARGET = Word.fromIntSignExtend(13);
  private static final Word TRACE_FIELD_SLOT = Word.fromIntSignExtend(14);
  private static final Word TRACE_ARRAY_ELEMENT = Word.fromIntSignExtend(15);
  private static final Word TRACE_STATIC_TARGET = Word.fromIntSignExtend(17);
  private static final Word TRACE_BOOT_ALLOC_SIZE = Word.fromIntSignExtend(18);

  /*
   * Debugging and trace reducing constants
   */
  public static final boolean OMIT_ALLOCS=false;
  public static final boolean OMIT_UPDATES=false;
  public static final boolean OMIT_BOOTALLOCS=false;
  public static final boolean OMIT_UNREACHABLES=false;
  public static final boolean OMIT_OTHERS=false;
  public static final boolean OMIT_OUTPUT=OMIT_ALLOCS && OMIT_UPDATES &&
                                          OMIT_OTHERS;


  /***********************************************************************
   *
   * Public methods
   */

  /**
   * Constructor
   *
   * @param pool The shared queue to which this queue will append its
   * buffers (when full or flushed) and from which it will aquire new
   * buffers when it has exhausted its own.
   */
  public TraceBuffer(SharedDeque pool) {
    super(pool);
  }

  /**
   * Push word onto the tracing queue.
   *
   * @param i The data to be pushed onto the tracing queue
   */
  @Inline
  public final void push(Word i) {
    checkTailInsert(1);
    uncheckedTailInsert(i.toAddress());
  }

  /**
   * Process the data in the tracing buffer, output information as needed.
   */
  public final void process() {
    Word traceState = TRACE_NEW_RECORD;
    int entriesNotFlushed = 0;
    boolean loggedRecord = false;
    /* First we must flush any remaining data */
    if (!OMIT_OUTPUT) Log.writeln();

    /* Process through the entire buffer. */
    while (checkDequeue(1)) {
      /* For speed and efficiency, we will actually process the data buffer by
         buffer and not by dequeue-ing each entry. */
      while (!bufferOffset(head).isZero()) {
        head = head.minus(BYTES_IN_ADDRESS);
        Word val = head.loadWord();
        if (traceState.EQ(TRACE_NEW_RECORD)) {
          loggedRecord = false;
          if (val.EQ(TRACE_GCSTART)) {
            if (!OMIT_OTHERS) {
              Log.write('G');
              Log.write('C');
              Log.writeln('B', true);
            }
          } else if (val.EQ(TRACE_GCEND)) {
            if (!OMIT_OTHERS) {
              Log.write('G');
              Log.write('C');
              Log.writeln('E', true);
            }
          } else {
            traceState = val;
          }
        } else {
          if (traceState.EQ(TRACE_EXACT_ALLOC) ||
              traceState.EQ(TRACE_ALLOC)) {
            if (!OMIT_ALLOCS) {
              Log.write((traceState.EQ(TRACE_EXACT_ALLOC)) ? 'A' : 'a');
              Log.write(' ');
              Log.write(val);
              loggedRecord = true;
            }
            traceState = TRACE_ALLOC_SIZE;
          } else if (traceState.EQ(TRACE_EXACT_IMMORTAL_ALLOC) ||
                     traceState.EQ(TRACE_IMMORTAL_ALLOC)) {
            if (!OMIT_ALLOCS) {
              Log.write((traceState.EQ(TRACE_EXACT_IMMORTAL_ALLOC)) ? 'I' : 'i');
              Log.write(' ');
              Log.write(val);
              loggedRecord = true;
            }
            traceState = TRACE_ALLOC_SIZE;
          } else if (traceState.EQ(TRACE_BOOT_ALLOC)) {
            if (!OMIT_BOOTALLOCS) {
              Log.write('B');
              Log.write(' ');
              Log.write(val);
              loggedRecord = true;
            }
            traceState = TRACE_BOOT_ALLOC_SIZE;
          } else if (traceState.EQ(TRACE_DEATH)) {
            if (!OMIT_UNREACHABLES) {
              Log.write('D');
              Log.write(' ');
              Log.write(val);
              loggedRecord = true;
            }
            traceState = TRACE_DEATH_TIME;
          } else if (traceState.EQ(TRACE_BOOT_ALLOC_SIZE)) {
            if (!OMIT_BOOTALLOCS)
              Log.write(val);
            traceState = TRACE_NEW_RECORD;
          } else if (traceState.EQ(TRACE_ALLOC_SIZE)) {
            if (!OMIT_ALLOCS)
              Log.write(val);
            traceState = TRACE_ALLOC_FP;
          } else if (traceState.EQ(TRACE_ALLOC_FP)) {
            if (!OMIT_ALLOCS)
              Log.write(val);
            traceState = TRACE_ALLOC_THREAD;
          } else if (traceState.EQ(TRACE_ALLOC_THREAD)) {
            if (!OMIT_ALLOCS)
              Log.write(val);
            traceState = TRACE_NEW_RECORD;
          } else if (traceState.EQ(TRACE_TIB_SET)) {
            if (!OMIT_UPDATES) {
              Log.write('T');
              Log.write(' ');
              Log.write(val);
              loggedRecord = true;
            }
            traceState = TRACE_TIB_VALUE;
          } else if (traceState.EQ(TRACE_STATIC_SET)) {
            if (!OMIT_UPDATES) {
              Log.write('S');
              Log.write(' ');
              Log.write(val);
              loggedRecord = true;
            }
            traceState = TRACE_STATIC_TARGET;
          } else if (traceState.EQ(TRACE_TIB_VALUE) ||
                     traceState.EQ(TRACE_STATIC_TARGET)) {
            if (!OMIT_UPDATES)
              Log.write(val);
            traceState = TRACE_NEW_RECORD;
          } else if (traceState.EQ(TRACE_DEATH_TIME)) {
            if (!OMIT_UNREACHABLES)
              Log.write(val);
            traceState = TRACE_NEW_RECORD;
          } else if (traceState.EQ(TRACE_FIELD_SET) ||
                     traceState.EQ(TRACE_ARRAY_SET)) {
            if (!OMIT_UPDATES) {
              Log.write('U');
              Log.write(' ');
              Log.write(val);
              loggedRecord = true;
            }
            traceState = TRACE_FIELD_SLOT;
          } else if (traceState.EQ(TRACE_FIELD_TARGET) ||
                     traceState.EQ(TRACE_ARRAY_TARGET)) {
            if (!OMIT_UPDATES)
              Log.write(val);
            traceState = TRACE_NEW_RECORD;
          } else if (traceState.EQ(TRACE_FIELD_SLOT) ||
                     traceState.EQ(TRACE_ARRAY_ELEMENT)) {
            if (!OMIT_UPDATES)
              Log.write(val);
            traceState = TRACE_FIELD_TARGET;
          } else {
            VM.assertions.fail("Cannot understand directive!\n");
          }
          if (traceState.EQ(TRACE_NEW_RECORD) && loggedRecord) {
            entriesNotFlushed++;
            Log.writeln();
          } else if (loggedRecord) {
              Log.write(' ');
          }
        }
        if (entriesNotFlushed == 10) {
          if (!OMIT_OUTPUT)
            Log.flush();
          entriesNotFlushed = 0;
        }
      }
    }
    resetLocal();
  }
}