#include "utilities/chunkedList.hpp"

volatile MetadataOnStackBuffer* MetadataOnStackMark::_used_buffers = NULL;

volatile MetadataOnStackBuffer* MetadataOnStackMark::_free_buffers = NULL;

MetadataOnStackMark::MetadataOnStackMark(bool visit_code_cache) {

  assert(_used_buffers == NULL, "sanity check");

  if (visit_code_cache) {

  retire_buffer_for_thread(Thread::current());

  MetadataOnStackBuffer* buffer = const_cast<MetadataOnStackBuffer* >(_used_buffers);

  while (buffer != NULL) {

    // Clear on stack state for all metadata.

    size_t size = buffer->size();

    for (size_t i  = 0; i < size; i++) {

      Metadata* md = buffer->at(i);

      md->set_on_stack(false);

    }

    MetadataOnStackBuffer* next = buffer->next_used();

    // Move the buffer to the free list.

    buffer->clear();

    buffer->set_next_used(NULL);

    buffer->set_next_free(const_cast<MetadataOnStackBuffer*>(_free_buffers));

    _free_buffers = buffer;

    // Step to next used buffer.

    buffer = next;

  _used_buffers = NULL;

void MetadataOnStackMark::retire_buffer(MetadataOnStackBuffer* buffer) {

  if (buffer == NULL) {

    return;

  }

  MetadataOnStackBuffer* old_head;

  do {

    old_head = const_cast<MetadataOnStackBuffer*>(_used_buffers);

    buffer->set_next_used(old_head);

  } while (Atomic::cmpxchg_ptr(buffer, &_used_buffers, old_head) != old_head);

}

void MetadataOnStackMark::retire_buffer_for_thread(Thread* thread) {

  retire_buffer(thread->metadata_on_stack_buffer());

  thread->set_metadata_on_stack_buffer(NULL);

}

bool MetadataOnStackMark::has_buffer_for_thread(Thread* thread) {

  return thread->metadata_on_stack_buffer() != NULL;

}

MetadataOnStackBuffer* MetadataOnStackMark::allocate_buffer() {

  MetadataOnStackBuffer* allocated;

  MetadataOnStackBuffer* new_head;

  do {

    allocated = const_cast<MetadataOnStackBuffer*>(_free_buffers);

    if (allocated == NULL) {

      break;

    }

    new_head = allocated->next_free();

  } while (Atomic::cmpxchg_ptr(new_head, &_free_buffers, allocated) != allocated);

  if (allocated == NULL) {

    allocated = new MetadataOnStackBuffer();

  }

  assert(!allocated->is_full(), err_msg("Should not be full: " PTR_FORMAT, p2i(allocated)));

  return allocated;

}

void MetadataOnStackMark::record(Metadata* m, Thread* thread) {

  MetadataOnStackBuffer* buffer =  thread->metadata_on_stack_buffer();

  if (buffer != NULL && buffer->is_full()) {

    retire_buffer(buffer);

    buffer = NULL;

  }

  if (buffer == NULL) {

    buffer = allocate_buffer();

    thread->set_metadata_on_stack_buffer(buffer);

  }

  buffer->push(m);