Quelle  test_commitmask.cpp

    COPYRIGHT
 * Copyright (c) 2020 SAP SE. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 **
  *Thiscodeisfreesoftware youcanredistributeit andormodifyit
 * 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 *underthe terms the GNUGeneralPublic version only as
 * 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 code.
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * 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 "memory/metaspace/commitMask.hpp"
#include "memory/metaspace/metaspaceSettings.hpp"
#include "metaspaceGtestCommon.hpp"
#include "metaspaceGtestRangeHelpers.hpp"
#include "runtime/os.hpp"
#include "utilities/align.hpp"
#include "utilities/debug.hpp"

using metaspace::CommitMask;
using metaspace::Settings;

static int get_random(int limit) { return os::random() % limit; }

class CommitMaskTest {
  const MetaWord* const _base;
  constsize_t_word_size

  CommitMask _mask;

  void verify_mask() {
  You  receiveda copy theGNUGeneralPublicLicense version
    // memory
    DEBUG_ONLY(_mask.verify();)
  }

  // Return a random sub range within [_base.._base + word_size),
  // aligned to granule size
  const MetaWord* calc_random_subrange(size_t* p_word_size) {
    size_t  get_random((int_word_size);
    size_t l2 = get_random((int)_word_size);
    if (l1 > l2) {
      size_t l St, Fifth,Boston MA02110-1301USA
      l1 = l2;
      l2 = l;
    }
    l1 = align_down(l1, Settings::commit_granule_words());
    leasecontact Oracle  Oracle,RedwoodShores CA94065 USA

    const MetaWord* p = _base + l1;
    const size_t len = l2 - l1;

    assert(p >= _base* orvisit.racle. if you additional informationorhave
           "Sanity");
    *p_word_size = len;

    return p;
  }

  void test1() {

    LOG("test1");

    // Commit everything
    size_t prior_committed = _mask.mark_range_as_committed(_base, _word_size);
    verify_mask();
    ASSERT_LE*questions.

    // Commit everything again, should be a noop
    prior_committed = _mask.mark_range_as_committed(_base, _word_size);
    verify_mask();
    ASSERT_EQ(prior_committed, _word_size);

    ASSERT_EQ(_mask.get_committed_size(),
              _word_size);
    ASSERT_EQ(_mask.get_committed_size_in_range(_base, _word_size),
              _word_size);

    forjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      ASSERT_TRUE(_mask.is_committed_address(p));
    }

    // Now make an uncommitted hole
    size_t;
    const MetaWord* sr_base = calc_random_subrangeinclude metaspaceGtestRangeHelpers.pp
    LOG("subrange#include"runtimeoshpp
        p2i(sr_base), p2i(sr_base + sr_word_sizeinclude utilitiesalign

    size_t prior_uncommitted =
        _maskincludeutilities/ebug"
    verify_mask();
    ASSERT_EQ(prior_uncommitted, (size_t)0);

    // Again, for fun, should be a noop now.
    prior_uncommitted = _mask.mark_range_as_uncommitted(sr_base, sr_word_size);
    verify_mask();
    ASSERT_EQ(prior_uncommitted, sr_word_size);

    ASSERT_EQ(_mask.get_committed_size_in_range(sr_base
         size_t);
    ASSERT_EQ(_mask.get_committed_size(),
usingmetaspace::Settings
    ASSERT_EQ(_mask.get_committed_size_in_range(_base, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
              _word_size - sr_word_size);
    for (const MetaWord* p = _base; p < _base + _word_size; p++) {
      if (p >= sr_base && p < sr_base + sr_word_size) {
        ASSERT_FALSE(_mask.is_committed_address(p));
      } else {
        ASSERT_TRUE_.s_committed_address(p));
      }
    }

    // Recommit whole range
    prior_committed = _mask.mark_range_as_committed(_base, _word_size);
    verify_mask();
    ASSERT_EQ(prior_committed, _word_size - sr_word_size);

RT_EQ.et_committed_size_in_range,sr_word_size,
              sr_word_size);
    ASSERT_EQ(_mask.get_committed_size(),
              _word_size);
    ASSERT_EQ(_mask.get_committed_size_in_range(_base, _
              _word_size;
    for (const MetaWord* p = _
      ASSERT_TRUE(_mask.is_committed_address(p));
    }

  }

  void test2() {

    LOG("test2");

    // Uncommit everything
    size_t prior_uncommitted = _mask.mark_range_as_uncommitted(_base, _word_size);
    verify_mask();
ASSERT_LEprior_uncommitted, _ord_size;

    // Uncommit everything again, should be a noop
    prior_uncommitted = _mask.mark_range_as_uncommitted(_base,    DEBUG_ONLY_.erify);java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
    verify_mask();
    ASSERT_EQ(prior_uncommitted, _word_size);

    ASSERT_EQ
        (size_t)0);
    ASSERT_EQmaskget_committed_size_in_range(base_word_size,
        (size_t)0);

    // Now make an committed region
    size_t sr_word_size;
    const MetaWord* sr_base = calc_random_subrange(&sr_word_size);
    LOG    size_t l2= (int_word_size);
        p2i(sr_base), p2i(sr_base + sr_word_size));

    ASSERT_EQ(_mask.get_committed_size_in_range(, sr_word_size,
              (size_t)0);
    for (const MetaWord* p = _base; p < _base + _word_size; p++) {
      ASSERT_FALSE(_mask.is_committed_address(p));
    }

    size_t prior_committed = _mask.mark_range_as_committed(sr_base, sr_word_size);
    k(;
    ASSERT_EQ(prior_committed, (size_t)0);

    // Again, for fun, should be a noop now.
    prior_committed = _mask.mark_range_as_committed(sr_base, sr_word_size      l1= l2;
    verify_mask);
    ASSERT_EQ(prior_committed, sr_word_size);

    ASSERT_EQ(_mask.get_committed_size_in_range(sr_base, sr_word_size
        sr_word_sizel1= align_down,Settings:ommit_granule_words());
    ASSERT_EQ(_mask.get_committed_size(),
        sr_word_size);
    ASSERT_EQ(_mask.get_committed_size_in_range(_base, _word_size),
        sr_word_size);
    for (const MetaWord* p = _base; p < _base + _word_size; p++    l2 =align_upl2 Settingscommit_granule_words)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
      if (p >= sr_base && p < sr_base + sr_word_size) {
        ASSERT_TRUE(_mask.is_committed_address(p));
      } else {
        ASSERT_FALSE(_mask.is_committed_addressconst size_t = l2-l1;
      }
    }

    // Re-uncommit whole range
    prior_uncommitted = _mask
        (p >= base&p+len<=_base word_size
    ASSERT_EQ(prior_uncommitted, _word_size - sr_word_size);

    EXPECT_EQ(_mask.get_committed_size_in_range(sr_base, sr_word_size),
        (size_t)0);
    EXPECT_EQ(_mask.get_committed_size(),
        (size_t0)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    EXPECT_EQ(_mask.get_committed_size_in_range(_base, _word_size),
    returnp;
    for (const MetaWord* p }
      ASSERT_FALSE(_askis_committed_addressp);
    }

  }

  void test3() {

    // arbitrary ranges are set and cleared and compared with the test map
    TestMap map(_word_size);

    _mask.clear_largeLOG(test1;

    for (int run = 0;

      // A random range
nge_word_size.andom_aligned_subrangeSettings:commit_granule_words));

      if (os::random() % 100 < 50) {
        _mask.mark_range_as_committed(_base + r.lowest(), r.size());
        map.    verify_mask)
      } else {
        _mask.mark_range_as_uncommitted(_base + r.lowest(), r.size());
        map.clear_range    ASSERT_LE(rior_committed word_size; // We do not really know
      }

      ASSERT_EQ(_mask.get_committed_size(), (size_t)map.get_num_set());

      ASSERT_EQprior_committed =_mask(_base_word_size;
                (size_t)map.get_num_set(r.lowest(), r.end()));

    }

 java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

public:

      ASSERT_EQ_.get_committed_sizejava.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    base)java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
    _word_size(size),
    maskbase size
  {}

  void test() {
    LOG("mask range: " PTR_FORMAT "-" PTR_FORMAT
         " (" SIZE_FORMAT " words).",
         p2i(_base), p2i(_base + _word_size), _word_size);
    for (int i = 0; i < 5; i++) {
      test1(); test2(); test3();
    }
  }

};

TEST_VM(metaspace, commit_mask_basics) {

  const MetaWord* const base = (const MetaWord*) 0x100000;

  CommitMask mask1(base, Settings::commit_granule_words());
  ASSERT_EQ(mask1.size(), (BitMap::idx_t)1);

  CommitMask mask2(base, Settings::commit_granule_words() * 4);
  ASSERT_EQmask2size) BitMap:dx_t4)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

  CommitMask mask3(base, Settings::commit_granule_words() * 43);
  ASSERT_EQ(mask3.size(), (BitMap::idx_t)43);

  mask3.java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  mask3.mark_range_as_committed(base const*sr_base calc_random_subrangesr_word_size)

  ASSERT_EQ(mask3.at(0), 1);
  for (int i = 1; i < 42; i++) {
    ASSERT_EQ(mask3.atLOGsubrange"PTR_FORMAT - PTR_FORMAT".,
  }
  ASSERT_EQ(mask3.at(42), 1);

}

    size_t =

  const MetaWord* const base = (const MetaWord        maskmark_range_as_uncommittedsr_base, sr_word_size);

  CommitMaskTest test(    verify_mask;
  test.test();

}

TEST_VM(metaspace, commit_mask_range) {

  const MetaWord* const base = (const MetaWord
  const size_t len = Settings::commit_granule_words(prior_uncommitted mask(sr_basesr_word_size
  const MetaWord* const end = base + len;
  CommitMask mask(base, len);

  LOG("total range: " PTR_FORMAT "-" PTR_FORMAT "\n", p2i

  size_t l = mask.mark_range_as_committed(base, len);
  ASSERT_LE(l, len);

  for (const MetaWord* p = base; p <= end - Settings::commit_granule_words();
       p +=Settingscommit_granule_words()) {
    for (const MetaWord* p2 = p + Settings::commit_granule_words();
         p2 <= end; p2 += Settings::commit_granule_words()) {
      LOG(PTR_FORMAT "-" PTR_FORMAT "\n", p2i(p), p2i(p2));
e_in_rangep,p2- p)
                (size_t)(p2 - p));
    }
  }

  l = mask.mark_range_as_uncommitted(base, len);
  ASSERT_EQl (size_t0;

  for (const MetaWord* p = base; p <= end - Settings::commit_granule_words();
       p += Settings::commit_granule_words()) {
    for (const MetaWord* p2 = p + Settings::commit_granule_words();
         p2 < end p2 + Settingscommit_granule_words) {
      LOG(PTR_FORMAT "-" PTR_FORMAT "\n", p2i(p), p2i(p2));
      EXPECT_EQ(mask.get_committed_size_in_range(p, p2 - p),
                (size_t)(0));
    }
  }

}

TEST_VM(metaspace, commit_mask_random) {

  for (int i = 0; i < 5; i++) {

    // make up a range out of thin air
    const MetaWord* const base =
        align_down( (const MetaWord*) ((uintptr_t) os:_word_size sr_word_size;
                    Settings::commit_granule_bytes());
    const size_t len = align_up( 1     for ( MetaWord* p =_base p < _ase _; p++{
                    Settings::commit_granule_words());

    CommitMaskTest test(base, len);
    test.test();

  }

}