/*
 * Copyright (c) 2019, SAP SE. All rights reserved.
 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * 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 "metaspace/metaspaceTestsCommon.hpp"



class MetachunkTest {

  CommitLimiter _commit_limiter;
  VirtualSpaceList _vs_list;
  ChunkManager _cm;

  Metachunk* alloc_chunk(chklvl_t lvl) {

    Metachunk* c = _cm.get_chunk(lvl, lvl);
    EXPECT_NOT_NULL(c);
    EXPECT_EQ(c->level(), lvl);
    check_chunk(c);

    DEBUG_ONLY(c->verify(true);)

    return c;
  }

  void check_chunk(const Metachunk* c) const {
    EXPECT_LE(c->used_words(), c->committed_words());
    EXPECT_LE(c->committed_words(), c->word_size());
    EXPECT_NOT_NULL(c->base());
    EXPECT_TRUE(_vs_list.contains(c->base()));
    EXPECT_TRUE(is_aligned(c->base(), MAX_CHUNK_BYTE_SIZE));
    EXPECT_TRUE(is_aligned(c->word_size(), MAX_CHUNK_WORD_SIZE));
    EXPECT_TRUE(metaspace::chklvl::is_valid_level(c->level()));

    if (c->next() != NULL) EXPECT_EQ(c->next()->prev(), c);
    if (c->prev() != NULL) EXPECT_EQ(c->prev()->next(), c);
    if (c->next_in_vs() != NULL) EXPECT_EQ(c->next_in_vs()->prev_in_vs(), c);
    if (c->prev_in_vs() != NULL) EXPECT_EQ(c->prev_in_vs()->next_in_vs(), c);

    DEBUG_ONLY(c->verify(true);)
  }

public:

  MetachunkTest(size_t commit_limit)
    : _commit_limiter(commit_limit),
      _vs_list("test_vs_list", &_commit_limiter),
      _cm("test_cm", &_vs_list)
  {
  }

  void test_random_allocs() {

    // Randomly alloc from a chunk until it is full.
    Metachunk* c = alloc_chunk(LOWEST_CHUNK_LEVEL);

    check_chunk(c);

    EXPECT_TRUE(c->is_in_use());
    EXPECT_EQ(c->used_words(), (size_t)0);

    // uncommit to start off with uncommitted chunk; then start allocating.
    c->set_free();
    c->uncommit();
    c->set_in_use();

    EXPECT_EQ(c->committed_words(), (size_t)0);

    RandSizeGenerator rgen(1, 256, 0.1f, 1024, 4096); // note: word sizes
    SizeCounter words_allocated;

    MetaWord* p = NULL;
    bool did_hit_commit_limit = false;
    do {

      const size_t alloc_size = align_up(rgen.get(), Metachunk::allocation_alignment_words);

      // Note: about net and raw sizes: these concepts only exist at the SpaceManager level.
      // At the chunk level (where we test here), we allocate exactly what we ask, in number of words.

      const bool may_hit_commit_limit =
          _commit_limiter.possible_expansion_words() <= align_up(alloc_size, Settings::commit_granule_words());

      p = c->allocate(alloc_size, &did_hit_commit_limit);
      LOG("Allocated " SIZE_FORMAT " words, chunk: " METACHUNK_FULL_FORMAT, alloc_size, METACHUNK_FULL_FORMAT_ARGS(c));

      check_chunk(c);

      if (p != NULL) {
        // From time to time deallocate to test deallocation. Since we do this on the very last allocation,
        // this should always work.
        if (os::random() % 100 > 95) {
          LOG("Test dealloc in place");
          EXPECT_TRUE(c->attempt_rollback_allocation(p, alloc_size));
        } else {
          fill_range_with_pattern(p, (uintx) this, alloc_size); // test that we can access this.
          words_allocated.increment_by(alloc_size);
          EXPECT_EQ(c->used_words(), words_allocated.get());
        }
      } else {
        // Allocating from a chunk can only fail for one of two reasons: Either the chunk is full, or
        // we attempted to increase the chunk's commit region and hit the commit limit.
        if (did_hit_commit_limit) {
          EXPECT_TRUE(may_hit_commit_limit);
        } else {
          // Chunk is full.
          EXPECT_LT(c->free_words(), alloc_size);
        }
      }

    } while(p != NULL);

    check_range_for_pattern(c->base(), (uintx) this, c->used_words());

    // At the end of the test return the chunk to the chunk manager to
    // avoid asserts on destruction time.
    _cm.return_chunk(c);

  }



};



TEST_VM(metaspace, metachunk_test_random_allocs_no_commit_limit) {

  // The test only allocates one root chunk and plays with it, so anything
  // above the size of a root chunk should not hit commit limit.
  MetachunkTest test(2 * MAX_CHUNK_WORD_SIZE);
  test.test_random_allocs();

}

TEST_VM(metaspace, metachunk_test_random_allocs_with_commit_limit) {

  // The test allocates one root chunk and plays with it, so a limit smaller
  // than root chunk size will be hit.
  MetachunkTest test(MAX_CHUNK_WORD_SIZE / 2);
  test.test_random_allocs();

}