bitset.inline.hpp

/*
 * 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.
 *
 */

#ifndef SHARE_JFR_LEAKPROFILER_CHAINS_BITSET_INLINE_HPP
#define SHARE_JFR_LEAKPROFILER_CHAINS_BITSET_INLINE_HPP

#include "jfr/leakprofiler/chains/bitset.hpp"

#include "jfr/recorder/storage/jfrVirtualMemory.hpp"
#include "memory/memRegion.hpp"
#include "utilities/bitMap.inline.hpp"
#include "utilities/hashtable.inline.hpp"

inline BitSet::BitMapFragmentTable::Entry* BitSet::BitMapFragmentTable::bucket(int i) const {
  return (Entry*)BasicHashtable<mtTracing>::bucket(i);
}

inline BitSet::BitMapFragmentTable::Entry* BitSet::BitMapFragmentTable::new_entry(unsigned int hash,
                                                                                  uintptr_t key,
                                                                                  CHeapBitMap* value) {
  Entry* entry = (Entry*)BasicHashtable<mtTracing>::new_entry(hash);
  entry->_key = key;
  entry->_value = value;
  return entry;
}

inline void BitSet::BitMapFragmentTable::add(uintptr_t key, CHeapBitMap* value) {
  unsigned hash = hash_segment(key);
  Entry* entry = new_entry(hash, key, value);
  BasicHashtable<mtTracing>::add_entry(hash_to_index(hash), entry);
}

inline CHeapBitMap** BitSet::BitMapFragmentTable::lookup(uintptr_t key) {
  unsigned hash = hash_segment(key);
  int index = hash_to_index(hash);
  for (Entry* e = bucket(index); e != NULL; e = e->next()) {
    if (e->hash() == hash && e->_key == key) {
      return &(e->_value);
    }
  }
  return NULL;
}

inline BitMap::idx_t BitSet::addr_to_bit(uintptr_t addr) const {
  return (addr & _bitmap_granularity_mask) >> LogMinObjAlignmentInBytes;
}

inline CHeapBitMap* BitSet::get_fragment_bits(uintptr_t addr) {
  uintptr_t granule = addr >> _bitmap_granularity_shift;
  if (granule == _last_fragment_granule) {
    return _last_fragment_bits;
  }
  CHeapBitMap* bits = NULL;

  CHeapBitMap** found = _bitmap_fragments.lookup(granule);
  if (found != NULL) {
    bits = *found;
  } else {
    BitMapFragment* fragment = new BitMapFragment(granule, _fragment_list);
    bits = fragment->bits();
    _fragment_list = fragment;
    if (_bitmap_fragments.number_of_entries() * 100 / _bitmap_fragments.table_size() > 25) {
      _bitmap_fragments.resize(_bitmap_fragments.table_size() * 2);
    }
    _bitmap_fragments.add(granule, bits);
  }

  _last_fragment_bits = bits;
  _last_fragment_granule = granule;

  return bits;
}

inline void BitSet::mark_obj(uintptr_t addr) {
  CHeapBitMap* bits = get_fragment_bits(addr);
  const BitMap::idx_t bit = addr_to_bit(addr);
  bits->set_bit(bit);
}

inline bool BitSet::is_marked(uintptr_t addr) {
  CHeapBitMap* bits = get_fragment_bits(addr);
  const BitMap::idx_t bit = addr_to_bit(addr);
  return bits->at(bit);
}

#endif // SHARE_JFR_LEAKPROFILER_CHAINS_BITSET_INLINE_HPP