/*
 * Copyright (c) 2019, Red Hat, Inc. All rights reserved.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 *
 */

#include "precompiled.hpp"

#include "runtime/threadCritical.hpp"
#include "services/mallocTracker.hpp"
#include "services/memTracker.hpp"
#include "services/virtualMemoryTracker.hpp"
#include "services/threadStackTracker.hpp"

volatile size_t ThreadStackTracker::_thread_count = 0;
SortedLinkedList<SimpleThreadStackSite, ThreadStackTracker::compare_thread_stack_base>* ThreadStackTracker::_simple_thread_stacks = NULL;

bool ThreadStackTracker::late_initialize(NMT_TrackingLevel level) {
  if (level == NMT_detail && !track_as_vm()) {
    _simple_thread_stacks = new (std::nothrow, ResourceObj::C_HEAP, mtNMT)
      SortedLinkedList<SimpleThreadStackSite, ThreadStackTracker::compare_thread_stack_base>();
    return (_simple_thread_stacks != NULL);
  }
  return true;
}

bool ThreadStackTracker::transition(NMT_TrackingLevel from, NMT_TrackingLevel to) {
  assert (from != NMT_minimal, "cannot convert from the lowest tracking level to anything");
  if (to == NMT_minimal) {
    assert(from == NMT_summary || from == NMT_detail, "Just check");
    ThreadCritical tc;
    if (_simple_thread_stacks != NULL) {
      delete _simple_thread_stacks;
      _simple_thread_stacks = NULL;
    }
  }
  return true;
}

int ThreadStackTracker::compare_thread_stack_base(const SimpleThreadStackSite& s1, const SimpleThreadStackSite& s2) {
  return s1.base() - s2.base();
}

void ThreadStackTracker::new_thread_stack(void* base, size_t size, const NativeCallStack& stack) {
  assert(MemTracker::tracking_level() >= NMT_summary, "Must be");
  assert(base != NULL, "Should have been filtered");
  if (track_as_vm()) {
    ThreadCritical tc;
    VirtualMemoryTracker::add_reserved_region((address)base, size, stack, mtThreadStack);
    _thread_count ++;
  } else {
    // Use a slot in mallocMemorySummary for thread stack bookkeeping
    MallocMemorySummary::record_malloc(size, mtThreadStack);
    if (MemTracker::tracking_level() == NMT_detail) {
      ThreadCritical tc;
      assert(_simple_thread_stacks != NULL, "Must be initialized");
      SimpleThreadStackSite site((address)base, size, stack);
      _simple_thread_stacks->add(site);
    }
  }
}

void ThreadStackTracker::delete_thread_stack(void* base, size_t size) {
  assert(MemTracker::tracking_level() >= NMT_summary, "Must be");
  assert(base != NULL, "Should have been filtered");
  if(track_as_vm()) {
    ThreadCritical tc;
    VirtualMemoryTracker::remove_released_region((address)base, size);
    _thread_count--;
  } else {
    // Use a slot in mallocMemorySummary for thread stack bookkeeping
    MallocMemorySummary::record_free(size, mtThreadStack);
    if (MemTracker::tracking_level() == NMT_detail) {
      ThreadCritical tc;
      assert(_simple_thread_stacks != NULL, "Must be initialized");
      SimpleThreadStackSite site((address)base, size);
      bool removed = _simple_thread_stacks->remove(site);
      assert(removed, "Must exist");
    }
  }
}

bool ThreadStackTracker::walk_simple_thread_stack_site(MallocSiteWalker* walker) {
  if (!track_as_vm()) {
    LinkedListImpl<MallocSite> _sites;
    {
      ThreadCritical tc;
      assert(_simple_thread_stacks != NULL, "Must be initialized");
      LinkedListIterator<SimpleThreadStackSite> itr(_simple_thread_stacks->head());
      const SimpleThreadStackSite* ts = itr.next();
      // Consolidate sites and convert to MallocSites, so we can piggyback into
      // malloc snapshot
      while (ts != NULL) {
        MallocSite site(*ts->call_stack(), mtThreadStack);
        MallocSite* exist = _sites.find(site);
        if (exist != NULL) {
          exist->allocate(ts->size());
        } else {
          site.allocate(ts->size());
          _sites.add(site);
        }
        ts = itr.next();
      }
    }

    // Piggyback to malloc snapshot
    LinkedListIterator<MallocSite> site_itr(_sites.head());
    const MallocSite* s = site_itr.next();
    while (s != NULL) {
      walker->do_malloc_site(s);
      s = site_itr.next();
    }
  }
  return true;
}