* Copyright (c) 2017, 2018, Oracle and/or its affiliates. All rights reserved.

#include "runtime/atomic.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/safepoint.hpp"

static ObjectSampler* _instance = NULL;

static ObjectSampler& instance() {

  assert(_instance != NULL, "invariant");

  return *_instance;

}

bool ObjectSampler::create(size_t size) {

  assert(SafepointSynchronize::is_at_safepoint(), "invariant");

  assert(_instance == NULL, "invariant");

  _instance = new ObjectSampler(size);

  return _instance != NULL;

}

bool ObjectSampler::is_created() {

  return _instance != NULL;

}

ObjectSampler* ObjectSampler::sampler() {

  assert(is_created(), "invariant");

  return _instance;

}

void ObjectSampler::destroy() {

  assert(SafepointSynchronize::is_at_safepoint(), "invariant");

  if (_instance != NULL) {

    ObjectSampler* const sampler = _instance;

    _instance = NULL;

    delete sampler;

  }

}

static volatile int _lock = 0;

ObjectSampler* ObjectSampler::acquire() {

  assert(is_created(), "invariant");

  while (Atomic::cmpxchg(1, &_lock, 0) == 1) {}

  return _instance;

}

void ObjectSampler::release() {

  assert(is_created(), "invariant");

  OrderAccess::fence();

  _lock = 0;

}

static traceid get_thread_id(JavaThread* thread) {

  if (thread->threadObj() == NULL) {

    return 0;

  }

  const JfrThreadLocal* const tl = thread->jfr_thread_local();

  assert(tl != NULL, "invariant");

  if (!tl->has_thread_checkpoint()) {

    JfrCheckpointManager::create_thread_checkpoint(thread);

  }

  assert(tl->has_thread_checkpoint(), "invariant");

  return tl->thread_id();

}

// Populates the thread local stack frames, but does not add them

// to the stacktrace repository (...yet, see stacktrace_id() below)

//

void ObjectSampler::fill_stacktrace(JfrStackTrace* stacktrace, JavaThread* thread) {

  assert(stacktrace != NULL, "invariant");

  assert(thread != NULL, "invariant");

  if (JfrEventSetting::has_stacktrace(EventOldObjectSample::eventId)) {

    JfrStackTraceRepository::fill_stacktrace_for(thread, stacktrace, 0);

  }

}

// We were successful in acquiring the try lock and have been selected for adding a sample.

// Go ahead with installing our previously taken stacktrace into the stacktrace repository.

//

traceid ObjectSampler::stacktrace_id(const JfrStackTrace* stacktrace, JavaThread* thread) {

  assert(stacktrace != NULL, "invariant");

  assert(stacktrace->hash() != 0, "invariant");

  const traceid stacktrace_id = JfrStackTraceRepository::add(stacktrace, thread);

  thread->jfr_thread_local()->set_cached_stack_trace_id(stacktrace_id, stacktrace->hash());

  return stacktrace_id;

}

void ObjectSampler::sample(HeapWord* obj, size_t allocated, JavaThread* thread) {

  assert(thread != NULL, "invariant");

  assert(is_created(), "invariant");

  const traceid thread_id = get_thread_id(thread);

  const JfrThreadLocal* const tl = thread->jfr_thread_local();

  JfrStackTrace stacktrace(tl->stackframes(), tl->stackdepth());

  fill_stacktrace(&stacktrace, thread);

  // try enter critical section

  JfrTryLock tryLock(&_lock);

  instance().add(obj, allocated, thread_id, &stacktrace, thread);

}

void ObjectSampler::add(HeapWord* obj, size_t allocated, traceid thread_id, JfrStackTrace* stacktrace, JavaThread* thread) {

  assert(stacktrace != NULL, "invariant");

  assert(thread_id != 0, "invariant");

  assert(thread != NULL, "invariant");

  assert(thread->jfr_thread_local()->has_thread_checkpoint(), "invariant");

  const unsigned int stacktrace_hash = stacktrace->hash();

  if (stacktrace_hash != 0) {

    sample->set_stack_trace_id(stacktrace_id(stacktrace, thread));

    sample->set_stack_trace_hash(stacktrace_hash);

void ObjectSampler::scavenge() {

    if (current->is_dead()) {

      remove_dead(current);

  _dead_samples = false;

void ObjectSampler::oops_do(BoolObjectClosure* is_alive, OopClosure* f) {

  assert(is_created(), "invariant");

  assert(SafepointSynchronize::is_at_safepoint(), "invariant");

  ObjectSampler& sampler = instance();

  ObjectSample* current = sampler._list->last();

    if (!current->is_dead()) {

      if (is_alive->do_object_b(current->object())) {

        // The weakly referenced object is alive, update pointer

        f->do_oop(const_cast<oop*>(current->object_addr()));

      } else {

        current->set_dead();

        sampler._dead_samples = true;

      }

  sampler._last_sweep = JfrTicks::now();

}

ObjectSample* ObjectSampler::last() const {

  return _list->last();

}

const ObjectSample* ObjectSampler::first() const {

  return _list->first();

}

const ObjectSample* ObjectSampler::last_resolved() const {

  return _list->last_resolved();

}

void ObjectSampler::set_last_resolved(const ObjectSample* sample) {

  _list->set_last_resolved(sample);

                                  );