src/hotspot/share/utilities/concurrentHashTable.inline.hpp
author stefank
Mon, 25 Nov 2019 12:33:15 +0100
changeset 59252 623722a6aeb9
parent 59247 56bf71d64d51
permissions -rw-r--r--
8234740: Harmonize parameter order in Atomic - cmpxchg Reviewed-by: rehn, dholmes
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
     1
/*
53244
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 53239
diff changeset
     2
 * Copyright (c) 2018, 2019, Oracle and/or its affiliates. All rights reserved.
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
     3
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
     4
 *
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
     5
 * This code is free software; you can redistribute it and/or modify it
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
     6
 * under the terms of the GNU General Public License version 2 only, as
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
     7
 * published by the Free Software Foundation.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
     8
 *
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
     9
 * This code is distributed in the hope that it will be useful, but WITHOUT
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    10
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    11
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    12
 * version 2 for more details (a copy is included in the LICENSE file that
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    13
 * accompanied this code).
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    14
 *
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    15
 * You should have received a copy of the GNU General Public License version
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    16
 * 2 along with this work; if not, write to the Free Software Foundation,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    17
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    18
 *
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    19
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    20
 * or visit www.oracle.com if you need additional information or have any
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    21
 * questions.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    22
 *
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    23
 */
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    24
53244
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 53239
diff changeset
    25
#ifndef SHARE_UTILITIES_CONCURRENTHASHTABLE_INLINE_HPP
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 53239
diff changeset
    26
#define SHARE_UTILITIES_CONCURRENTHASHTABLE_INLINE_HPP
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    27
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    28
#include "memory/allocation.inline.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    29
#include "runtime/atomic.hpp"
50429
83aec1d357d4 8204301: Make OrderAccess functions available to hpp rather than inline.hpp files
coleenp
parents: 50158
diff changeset
    30
#include "runtime/orderAccess.hpp"
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    31
#include "runtime/prefetch.inline.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    32
#include "utilities/concurrentHashTable.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    33
#include "utilities/globalCounter.inline.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    34
#include "utilities/numberSeq.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    35
#include "utilities/spinYield.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    36
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    37
// 2^30 = 1G buckets
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    38
#define SIZE_BIG_LOG2 30
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    39
// 2^5  = 32 buckets
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    40
#define SIZE_SMALL_LOG2 5
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    41
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    42
// Number from spinYield.hpp. In some loops SpinYield would be unfair.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    43
#define SPINPAUSES_PER_YIELD 8192
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    44
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    45
#ifdef ASSERT
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    46
#ifdef _LP64
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    47
// Two low bits are not usable.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    48
static const void* POISON_PTR = (void*)UCONST64(0xfbadbadbadbadbac);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    49
#else
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    50
// Two low bits are not usable.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    51
static const void* POISON_PTR = (void*)0xffbadbac;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    52
#endif
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    53
#endif
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    54
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    55
// Node
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    56
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    57
inline typename ConcurrentHashTable<CONFIG, F>::Node*
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    58
ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    59
  Node::next() const
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    60
{
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
    61
  return Atomic::load_acquire(&_next);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    62
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    63
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    64
// Bucket
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    65
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    66
inline typename ConcurrentHashTable<CONFIG, F>::Node*
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    67
ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    68
  Bucket::first_raw() const
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    69
{
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
    70
  return Atomic::load_acquire(&_first);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    71
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    72
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    73
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    74
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    75
  Bucket::release_assign_node_ptr(
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    76
    typename ConcurrentHashTable<CONFIG, F>::Node* const volatile * dst,
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    77
    typename ConcurrentHashTable<CONFIG, F>::Node* node) const
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    78
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    79
  // Due to this assert this methods is not static.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    80
  assert(is_locked(), "Must be locked.");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    81
  Node** tmp = (Node**)dst;
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
    82
  Atomic::release_store(tmp, clear_set_state(node, *dst));
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    83
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    84
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    85
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    86
inline typename ConcurrentHashTable<CONFIG, F>::Node*
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    87
ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    88
  Bucket::first() const
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    89
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    90
  // We strip the states bit before returning the ptr.
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
    91
  return clear_state(Atomic::load_acquire(&_first));
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    92
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    93
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    94
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
    95
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    96
  Bucket::have_redirect() const
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    97
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    98
  return is_state(first_raw(), STATE_REDIRECT_BIT);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
    99
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   100
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   101
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   102
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   103
  Bucket::is_locked() const
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   104
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   105
  return is_state(first_raw(), STATE_LOCK_BIT);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   106
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   107
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   108
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   109
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   110
  Bucket::lock()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   111
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   112
  int i = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   113
  // SpinYield would be unfair here
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   114
  while (!this->trylock()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   115
    if ((++i) == SPINPAUSES_PER_YIELD) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   116
      // On contemporary OS yielding will give CPU to another runnable thread if
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   117
      // there is no CPU available.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   118
      os::naked_yield();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   119
      i = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   120
    } else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   121
      SpinPause();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   122
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   123
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   124
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   125
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   126
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   127
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   128
  Bucket::release_assign_last_node_next(
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   129
     typename ConcurrentHashTable<CONFIG, F>::Node* node)
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   130
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   131
  assert(is_locked(), "Must be locked.");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   132
  Node* const volatile * ret = first_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   133
  while (clear_state(*ret) != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   134
    ret = clear_state(*ret)->next_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   135
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   136
  release_assign_node_ptr(ret, node);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   137
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   138
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   139
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   140
inline bool ConcurrentHashTable<CONFIG, F>::
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   141
  Bucket::cas_first(typename ConcurrentHashTable<CONFIG, F>::Node* node,
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   142
                    typename ConcurrentHashTable<CONFIG, F>::Node* expect
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   143
                    )
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   144
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   145
  if (is_locked()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   146
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   147
  }
59252
623722a6aeb9 8234740: Harmonize parameter order in Atomic - cmpxchg
stefank
parents: 59247
diff changeset
   148
  if (Atomic::cmpxchg(&_first, expect, node) == expect) {
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   149
    return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   150
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   151
  return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   152
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   153
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   154
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   155
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   156
  Bucket::trylock()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   157
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   158
  if (is_locked()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   159
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   160
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   161
  // We will expect a clean first pointer.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   162
  Node* tmp = first();
59252
623722a6aeb9 8234740: Harmonize parameter order in Atomic - cmpxchg
stefank
parents: 59247
diff changeset
   163
  if (Atomic::cmpxchg(&_first, tmp, set_state(tmp, STATE_LOCK_BIT)) == tmp) {
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   164
    return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   165
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   166
  return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   167
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   168
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   169
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   170
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   171
  Bucket::unlock()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   172
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   173
  assert(is_locked(), "Must be locked.");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   174
  assert(!have_redirect(),
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   175
         "Unlocking a bucket after it has reached terminal state.");
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
   176
  Atomic::release_store(&_first, clear_state(first()));
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   177
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   178
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   179
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   180
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   181
  Bucket::redirect()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   182
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   183
  assert(is_locked(), "Must be locked.");
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
   184
  Atomic::release_store(&_first, set_state(_first, STATE_REDIRECT_BIT));
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   185
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   186
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   187
// InternalTable
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   188
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   189
inline ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   190
  InternalTable::InternalTable(size_t log2_size)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   191
    : _log2_size(log2_size), _size(((size_t)1ul) << _log2_size),
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   192
      _hash_mask(~(~((size_t)0) << _log2_size))
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   193
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   194
  assert(_log2_size >= SIZE_SMALL_LOG2 && _log2_size <= SIZE_BIG_LOG2,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   195
         "Bad size");
53344
cfc839f28b89 8216426: Usage of array placement new may lead to memory corruption
mdoerr
parents: 53244
diff changeset
   196
  _buckets = NEW_C_HEAP_ARRAY(Bucket, _size, F);
cfc839f28b89 8216426: Usage of array placement new may lead to memory corruption
mdoerr
parents: 53244
diff changeset
   197
  // Use placement new for each element instead of new[] which could use more
cfc839f28b89 8216426: Usage of array placement new may lead to memory corruption
mdoerr
parents: 53244
diff changeset
   198
  // memory than allocated.
cfc839f28b89 8216426: Usage of array placement new may lead to memory corruption
mdoerr
parents: 53244
diff changeset
   199
  for (size_t i = 0; i < _size; ++i) {
cfc839f28b89 8216426: Usage of array placement new may lead to memory corruption
mdoerr
parents: 53244
diff changeset
   200
    new (_buckets + i) Bucket();
cfc839f28b89 8216426: Usage of array placement new may lead to memory corruption
mdoerr
parents: 53244
diff changeset
   201
  }
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   202
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   203
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   204
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   205
inline ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   206
  InternalTable::~InternalTable()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   207
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   208
  FREE_C_HEAP_ARRAY(Bucket, _buckets);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   209
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   210
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   211
// ScopedCS
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   212
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   213
inline ConcurrentHashTable<CONFIG, F>::
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   214
  ScopedCS::ScopedCS(Thread* thread, ConcurrentHashTable<CONFIG, F>* cht)
52332
d2a3503c72f7 8212827: GlobalCounter should support nested critical sections
kbarrett
parents: 51405
diff changeset
   215
    : _thread(thread),
d2a3503c72f7 8212827: GlobalCounter should support nested critical sections
kbarrett
parents: 51405
diff changeset
   216
      _cht(cht),
d2a3503c72f7 8212827: GlobalCounter should support nested critical sections
kbarrett
parents: 51405
diff changeset
   217
      _cs_context(GlobalCounter::critical_section_begin(_thread))
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   218
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   219
  // This version is published now.
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
   220
  if (Atomic::load_acquire(&_cht->_invisible_epoch) != NULL) {
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
   221
    Atomic::release_store_fence(&_cht->_invisible_epoch, (Thread*)NULL);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   222
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   223
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   224
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   225
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   226
inline ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   227
  ScopedCS::~ScopedCS()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   228
{
52332
d2a3503c72f7 8212827: GlobalCounter should support nested critical sections
kbarrett
parents: 51405
diff changeset
   229
  GlobalCounter::critical_section_end(_thread, _cs_context);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   230
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   231
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   232
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   233
template <typename LOOKUP_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   234
inline typename CONFIG::Value* ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   235
  MultiGetHandle::get(LOOKUP_FUNC& lookup_f, bool* grow_hint)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   236
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   237
  return ScopedCS::_cht->internal_get(ScopedCS::_thread, lookup_f, grow_hint);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   238
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   239
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   240
// HaveDeletables
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   241
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   242
template <typename EVALUATE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   243
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   244
  HaveDeletables<true, EVALUATE_FUNC>::have_deletable(Bucket* bucket,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   245
                                                      EVALUATE_FUNC& eval_f,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   246
                                                      Bucket* prefetch_bucket)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   247
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   248
  // Instantiated for pointer type (true), so we can use prefetch.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   249
  // When visiting all Nodes doing this prefetch give around 30%.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   250
  Node* pref = prefetch_bucket != NULL ? prefetch_bucket->first() : NULL;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   251
  for (Node* next = bucket->first(); next != NULL ; next = next->next()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   252
    if (pref != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   253
      Prefetch::read(*pref->value(), 0);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   254
      pref = pref->next();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   255
    }
50958
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   256
    // Read next() Node* once.  May be racing with a thread moving the next
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   257
    // pointers.
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   258
    Node* next_pref = next->next();
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   259
    if (next_pref != NULL) {
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   260
      Prefetch::read(*next_pref->value(), 0);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   261
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   262
    if (eval_f(next->value())) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   263
      return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   264
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   265
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   266
  return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   267
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   268
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   269
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   270
template <bool b, typename EVALUATE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   271
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   272
  HaveDeletables<b, EVALUATE_FUNC>::have_deletable(Bucket* bucket,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   273
                                                   EVALUATE_FUNC& eval_f,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   274
                                                   Bucket* preb)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   275
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   276
  for (Node* next = bucket->first(); next != NULL ; next = next->next()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   277
    if (eval_f(next->value())) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   278
      return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   279
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   280
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   281
  return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   282
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   283
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   284
// ConcurrentHashTable
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   285
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   286
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   287
  write_synchonize_on_visible_epoch(Thread* thread)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   288
{
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   289
  assert(_resize_lock_owner == thread, "Re-size lock not held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   290
  OrderAccess::fence(); // Prevent below load from floating up.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   291
  // If no reader saw this version we can skip write_synchronize.
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
   292
  if (Atomic::load_acquire(&_invisible_epoch) == thread) {
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   293
    return;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   294
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   295
  assert(_invisible_epoch == NULL, "Two thread doing bulk operations");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   296
  // We set this/next version that we are synchronizing for to not published.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   297
  // A reader will zero this flag if it reads this/next version.
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
   298
  Atomic::release_store(&_invisible_epoch, thread);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   299
  GlobalCounter::write_synchronize();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   300
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   301
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   302
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   303
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   304
  try_resize_lock(Thread* locker)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   305
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   306
  if (_resize_lock->try_lock()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   307
    if (_resize_lock_owner != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   308
      assert(locker != _resize_lock_owner, "Already own lock");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   309
      // We got mutex but internal state is locked.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   310
      _resize_lock->unlock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   311
      return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   312
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   313
  } else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   314
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   315
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   316
  _invisible_epoch = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   317
  _resize_lock_owner = locker;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   318
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   319
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   320
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   321
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   322
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   323
  lock_resize_lock(Thread* locker)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   324
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   325
  size_t i = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   326
  // If lock is hold by some other thread, the chances that it is return quick
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   327
  // is low. So we will prefer yielding.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   328
  SpinYield yield(1, 512);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   329
  do {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   330
    _resize_lock->lock_without_safepoint_check();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   331
    // If holder of lock dropped mutex for safepoint mutex might be unlocked,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   332
    // and _resize_lock_owner will contain the owner.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   333
    if (_resize_lock_owner != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   334
      assert(locker != _resize_lock_owner, "Already own lock");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   335
      // We got mutex but internal state is locked.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   336
      _resize_lock->unlock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   337
      yield.wait();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   338
    } else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   339
      break;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   340
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   341
  } while(true);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   342
  _resize_lock_owner = locker;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   343
  _invisible_epoch = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   344
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   345
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   346
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   347
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   348
  unlock_resize_lock(Thread* locker)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   349
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   350
  _invisible_epoch = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   351
  assert(locker == _resize_lock_owner, "Not unlocked by locker.");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   352
  _resize_lock_owner = NULL;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   353
  _resize_lock->unlock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   354
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   355
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   356
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   357
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   358
  free_nodes()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   359
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   360
  // We assume we are not MT during freeing.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   361
  for (size_t node_it = 0; node_it < _table->_size; node_it++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   362
    Bucket* bucket = _table->get_buckets() + node_it;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   363
    Node* node = bucket->first();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   364
    while (node != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   365
      Node* free_node = node;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   366
      node = node->next();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   367
      Node::destroy_node(free_node);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   368
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   369
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   370
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   371
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   372
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   373
inline typename ConcurrentHashTable<CONFIG, F>::InternalTable*
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   374
ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   375
  get_table() const
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   376
{
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
   377
  return Atomic::load_acquire(&_table);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   378
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   379
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   380
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   381
inline typename ConcurrentHashTable<CONFIG, F>::InternalTable*
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   382
ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   383
  get_new_table() const
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   384
{
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
   385
  return Atomic::load_acquire(&_new_table);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   386
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   387
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   388
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   389
inline typename ConcurrentHashTable<CONFIG, F>::InternalTable*
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   390
ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   391
  set_table_from_new()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   392
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   393
  InternalTable* old_table = _table;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   394
  // Publish the new table.
59247
56bf71d64d51 8234562: Move OrderAccess::release_store*/load_acquire to Atomic
stefank
parents: 58291
diff changeset
   395
  Atomic::release_store(&_table, _new_table);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   396
  // All must see this.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   397
  GlobalCounter::write_synchronize();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   398
  // _new_table not read any more.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   399
  _new_table = NULL;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   400
  DEBUG_ONLY(_new_table = (InternalTable*)POISON_PTR;)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   401
  return old_table;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   402
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   403
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   404
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   405
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   406
  internal_grow_range(Thread* thread, size_t start, size_t stop)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   407
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   408
  assert(stop <= _table->_size, "Outside backing array");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   409
  assert(_new_table != NULL, "Grow not proper setup before start");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   410
  // The state is also copied here. Hence all buckets in new table will be
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   411
  // locked. I call the siblings odd/even, where even have high bit 0 and odd
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   412
  // have high bit 1.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   413
  for (size_t even_index = start; even_index < stop; even_index++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   414
    Bucket* bucket = _table->get_bucket(even_index);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   415
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   416
    bucket->lock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   417
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   418
    size_t odd_index = even_index + _table->_size;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   419
    _new_table->get_buckets()[even_index] = *bucket;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   420
    _new_table->get_buckets()[odd_index] = *bucket;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   421
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   422
    // Moves lockers go to new table, where they will wait until unlock() below.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   423
    bucket->redirect(); /* Must release stores above */
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   424
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   425
    // When this is done we have separated the nodes into corresponding buckets
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   426
    // in new table.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   427
    if (!unzip_bucket(thread, _table, _new_table, even_index, odd_index)) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   428
      // If bucket is empty, unzip does nothing.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   429
      // We must make sure readers go to new table before we poison the bucket.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   430
      DEBUG_ONLY(GlobalCounter::write_synchronize();)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   431
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   432
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   433
    // Unlock for writes into the new table buckets.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   434
    _new_table->get_bucket(even_index)->unlock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   435
    _new_table->get_bucket(odd_index)->unlock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   436
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   437
    DEBUG_ONLY(
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   438
       bucket->release_assign_node_ptr(
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   439
          _table->get_bucket(even_index)->first_ptr(), (Node*)POISON_PTR);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   440
    )
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   441
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   442
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   443
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   444
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   445
template <typename LOOKUP_FUNC, typename DELETE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   446
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   447
  internal_remove(Thread* thread, LOOKUP_FUNC& lookup_f, DELETE_FUNC& delete_f)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   448
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   449
  Bucket* bucket = get_bucket_locked(thread, lookup_f.get_hash());
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   450
  assert(bucket->is_locked(), "Must be locked.");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   451
  Node* const volatile * rem_n_prev = bucket->first_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   452
  Node* rem_n = bucket->first();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   453
  bool have_dead = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   454
  while (rem_n != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   455
    if (lookup_f.equals(rem_n->value(), &have_dead)) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   456
      bucket->release_assign_node_ptr(rem_n_prev, rem_n->next());
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   457
      break;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   458
    } else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   459
      rem_n_prev = rem_n->next_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   460
      rem_n = rem_n->next();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   461
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   462
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   463
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   464
  bucket->unlock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   465
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   466
  if (rem_n == NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   467
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   468
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   469
  // Publish the deletion.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   470
  GlobalCounter::write_synchronize();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   471
  delete_f(rem_n->value());
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   472
  Node::destroy_node(rem_n);
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
   473
  JFR_ONLY(_stats_rate.remove();)
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   474
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   475
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   476
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   477
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   478
template <typename EVALUATE_FUNC, typename DELETE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   479
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   480
  do_bulk_delete_locked_for(Thread* thread, size_t start_idx, size_t stop_idx,
50608
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing
rehn
parents: 50445
diff changeset
   481
                            EVALUATE_FUNC& eval_f, DELETE_FUNC& del_f, bool is_mt)
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   482
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   483
  // Here we have resize lock so table is SMR safe, and there is no new
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   484
  // table. Can do this in parallel if we want.
50608
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing
rehn
parents: 50445
diff changeset
   485
  assert((is_mt && _resize_lock_owner != NULL) ||
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing
rehn
parents: 50445
diff changeset
   486
         (!is_mt && _resize_lock_owner == thread), "Re-size lock not held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   487
  Node* ndel[BULK_DELETE_LIMIT];
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   488
  InternalTable* table = get_table();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   489
  assert(start_idx < stop_idx, "Must be");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   490
  assert(stop_idx <= _table->_size, "Must be");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   491
  // Here manual do critical section since we don't want to take the cost of
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   492
  // locking the bucket if there is nothing to delete. But we can have
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   493
  // concurrent single deletes. The _invisible_epoch can only be used by the
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   494
  // owner of _resize_lock, us here. There we should not changed it in our
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   495
  // own read-side.
52332
d2a3503c72f7 8212827: GlobalCounter should support nested critical sections
kbarrett
parents: 51405
diff changeset
   496
  GlobalCounter::CSContext cs_context = GlobalCounter::critical_section_begin(thread);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   497
  for (size_t bucket_it = start_idx; bucket_it < stop_idx; bucket_it++) {
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   498
    Bucket* bucket = table->get_bucket(bucket_it);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   499
    Bucket* prefetch_bucket = (bucket_it+1) < stop_idx ?
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   500
                              table->get_bucket(bucket_it+1) : NULL;
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   501
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   502
    if (!HaveDeletables<IsPointer<VALUE>::value, EVALUATE_FUNC>::
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   503
        have_deletable(bucket, eval_f, prefetch_bucket)) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   504
        // Nothing to remove in this bucket.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   505
        continue;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   506
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   507
52332
d2a3503c72f7 8212827: GlobalCounter should support nested critical sections
kbarrett
parents: 51405
diff changeset
   508
    GlobalCounter::critical_section_end(thread, cs_context);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   509
    // We left critical section but the bucket cannot be removed while we hold
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   510
    // the _resize_lock.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   511
    bucket->lock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   512
    size_t nd = delete_check_nodes(bucket, eval_f, BULK_DELETE_LIMIT, ndel);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   513
    bucket->unlock();
50608
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing
rehn
parents: 50445
diff changeset
   514
    if (is_mt) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing
rehn
parents: 50445
diff changeset
   515
      GlobalCounter::write_synchronize();
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing
rehn
parents: 50445
diff changeset
   516
    } else {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing
rehn
parents: 50445
diff changeset
   517
      write_synchonize_on_visible_epoch(thread);
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing
rehn
parents: 50445
diff changeset
   518
    }
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   519
    for (size_t node_it = 0; node_it < nd; node_it++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   520
      del_f(ndel[node_it]->value());
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   521
      Node::destroy_node(ndel[node_it]);
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
   522
      JFR_ONLY(_stats_rate.remove();)
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   523
      DEBUG_ONLY(ndel[node_it] = (Node*)POISON_PTR;)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   524
    }
52332
d2a3503c72f7 8212827: GlobalCounter should support nested critical sections
kbarrett
parents: 51405
diff changeset
   525
    cs_context = GlobalCounter::critical_section_begin(thread);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   526
  }
52332
d2a3503c72f7 8212827: GlobalCounter should support nested critical sections
kbarrett
parents: 51405
diff changeset
   527
  GlobalCounter::critical_section_end(thread, cs_context);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   528
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   529
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   530
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   531
template <typename LOOKUP_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   532
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   533
  delete_in_bucket(Thread* thread, Bucket* bucket, LOOKUP_FUNC& lookup_f)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   534
{
51405
8b23aa7cef47 8195100: Use a low latency hashtable for SymbolTable
gziemski
parents: 51334
diff changeset
   535
  assert(bucket->is_locked(), "Must be locked.");
8b23aa7cef47 8195100: Use a low latency hashtable for SymbolTable
gziemski
parents: 51334
diff changeset
   536
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   537
  size_t dels = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   538
  Node* ndel[BULK_DELETE_LIMIT];
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   539
  Node* const volatile * rem_n_prev = bucket->first_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   540
  Node* rem_n = bucket->first();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   541
  while (rem_n != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   542
    bool is_dead = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   543
    lookup_f.equals(rem_n->value(), &is_dead);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   544
    if (is_dead) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   545
      ndel[dels++] = rem_n;
50958
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   546
      Node* next_node = rem_n->next();
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   547
      bucket->release_assign_node_ptr(rem_n_prev, next_node);
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   548
      rem_n = next_node;
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   549
      if (dels == BULK_DELETE_LIMIT) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   550
        break;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   551
      }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   552
    } else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   553
      rem_n_prev = rem_n->next_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   554
      rem_n = rem_n->next();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   555
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   556
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   557
  if (dels > 0) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   558
    GlobalCounter::write_synchronize();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   559
    for (size_t node_it = 0; node_it < dels; node_it++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   560
      Node::destroy_node(ndel[node_it]);
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
   561
      JFR_ONLY(_stats_rate.remove();)
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   562
      DEBUG_ONLY(ndel[node_it] = (Node*)POISON_PTR;)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   563
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   564
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   565
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   566
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   567
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   568
inline typename ConcurrentHashTable<CONFIG, F>::Bucket*
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   569
ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   570
  get_bucket(uintx hash) const
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   571
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   572
  InternalTable* table = get_table();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   573
  Bucket* bucket = get_bucket_in(table, hash);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   574
  if (bucket->have_redirect()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   575
    table = get_new_table();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   576
    bucket = get_bucket_in(table, hash);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   577
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   578
  return bucket;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   579
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   580
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   581
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   582
inline typename ConcurrentHashTable<CONFIG, F>::Bucket*
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   583
ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   584
  get_bucket_locked(Thread* thread, const uintx hash)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   585
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   586
  Bucket* bucket;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   587
  int i = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   588
  // SpinYield would be unfair here
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   589
  while(true) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   590
    {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   591
      // We need a critical section to protect the table itself. But if we fail
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   592
      // we must leave critical section otherwise we would deadlock.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   593
      ScopedCS cs(thread, this);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   594
      bucket = get_bucket(hash);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   595
      if (bucket->trylock()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   596
        break; /* ends critical section */
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   597
      }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   598
    } /* ends critical section */
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   599
    if ((++i) == SPINPAUSES_PER_YIELD) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   600
      // On contemporary OS yielding will give CPU to another runnable thread if
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   601
      // there is no CPU available.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   602
      os::naked_yield();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   603
      i = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   604
    } else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   605
      SpinPause();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   606
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   607
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   608
  return bucket;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   609
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   610
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   611
// Always called within critical section
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   612
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   613
template <typename LOOKUP_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   614
typename ConcurrentHashTable<CONFIG, F>::Node*
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   615
ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   616
  get_node(const Bucket* const bucket, LOOKUP_FUNC& lookup_f,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   617
           bool* have_dead, size_t* loops) const
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   618
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   619
  size_t loop_count = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   620
  Node* node = bucket->first();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   621
  while (node != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   622
    bool is_dead = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   623
    ++loop_count;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   624
    if (lookup_f.equals(node->value(), &is_dead)) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   625
      break;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   626
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   627
    if (is_dead && !(*have_dead)) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   628
      *have_dead = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   629
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   630
    node = node->next();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   631
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   632
  if (loops != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   633
    *loops = loop_count;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   634
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   635
  return node;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   636
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   637
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   638
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   639
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   640
  unzip_bucket(Thread* thread, InternalTable* old_table,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   641
               InternalTable* new_table, size_t even_index, size_t odd_index)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   642
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   643
  Node* aux = old_table->get_bucket(even_index)->first();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   644
  if (aux == NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   645
    // This is an empty bucket and in debug we poison first ptr in bucket.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   646
    // Therefore we must make sure no readers are looking at this bucket.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   647
    // If we don't do a write_synch here, caller must do it.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   648
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   649
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   650
  Node* delete_me = NULL;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   651
  Node* const volatile * even = new_table->get_bucket(even_index)->first_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   652
  Node* const volatile * odd = new_table->get_bucket(odd_index)->first_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   653
  while (aux != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   654
    bool dead_hash = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   655
    size_t aux_hash = CONFIG::get_hash(*aux->value(), &dead_hash);
50958
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   656
    Node* aux_next = aux->next();
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   657
    if (dead_hash) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   658
      delete_me = aux;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   659
      // This item is dead, move both list to next
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   660
      new_table->get_bucket(odd_index)->release_assign_node_ptr(odd,
50958
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   661
                                                                aux_next);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   662
      new_table->get_bucket(even_index)->release_assign_node_ptr(even,
50958
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   663
                                                                 aux_next);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   664
    } else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   665
      size_t aux_index = bucket_idx_hash(new_table, aux_hash);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   666
      if (aux_index == even_index) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   667
        // This is a even, so move odd to aux/even next
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   668
        new_table->get_bucket(odd_index)->release_assign_node_ptr(odd,
50958
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   669
                                                                  aux_next);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   670
        // Keep in even list
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   671
        even = aux->next_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   672
      } else if (aux_index == odd_index) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   673
        // This is a odd, so move odd to aux/odd next
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   674
        new_table->get_bucket(even_index)->release_assign_node_ptr(even,
50958
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   675
                                                                   aux_next);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   676
        // Keep in odd list
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   677
        odd = aux->next_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   678
      } else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   679
        fatal("aux_index does not match even or odd indices");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   680
      }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   681
    }
50958
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   682
    aux = aux_next;
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   683
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   684
    // We can only move 1 pointer otherwise a reader might be moved to the wrong
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   685
    // chain. E.g. looking for even hash value but got moved to the odd bucket
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   686
    // chain.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   687
    write_synchonize_on_visible_epoch(thread);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   688
    if (delete_me != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   689
      Node::destroy_node(delete_me);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   690
      delete_me = NULL;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   691
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   692
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   693
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   694
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   695
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   696
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   697
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   698
  internal_shrink_prolog(Thread* thread, size_t log2_size)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   699
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   700
  if (!try_resize_lock(thread)) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   701
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   702
  }
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   703
  assert(_resize_lock_owner == thread, "Re-size lock not held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   704
  if (_table->_log2_size == _log2_start_size ||
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   705
      _table->_log2_size <= log2_size) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   706
    unlock_resize_lock(thread);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   707
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   708
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   709
  _new_table = new InternalTable(_table->_log2_size - 1);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   710
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   711
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   712
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   713
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   714
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   715
  internal_shrink_epilog(Thread* thread)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   716
{
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   717
  assert(_resize_lock_owner == thread, "Re-size lock not held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   718
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   719
  InternalTable* old_table = set_table_from_new();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   720
  _size_limit_reached = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   721
  unlock_resize_lock(thread);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   722
#ifdef ASSERT
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   723
  for (size_t i = 0; i < old_table->_size; i++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   724
    assert(old_table->get_bucket(i++)->first() == POISON_PTR,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   725
           "No poison found");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   726
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   727
#endif
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   728
  // ABA safe, old_table not visible to any other threads.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   729
  delete old_table;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   730
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   731
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   732
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   733
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   734
  internal_shrink_range(Thread* thread, size_t start, size_t stop)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   735
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   736
  // The state is also copied here.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   737
  // Hence all buckets in new table will be locked.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   738
  for (size_t bucket_it = start; bucket_it < stop; bucket_it++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   739
    size_t even_hash_index = bucket_it; // High bit 0
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   740
    size_t odd_hash_index = bucket_it + _new_table->_size; // High bit 1
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   741
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   742
    Bucket* b_old_even = _table->get_bucket(even_hash_index);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   743
    Bucket* b_old_odd  = _table->get_bucket(odd_hash_index);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   744
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   745
    b_old_even->lock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   746
    b_old_odd->lock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   747
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   748
    _new_table->get_buckets()[bucket_it] = *b_old_even;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   749
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   750
    // Put chains together.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   751
    _new_table->get_bucket(bucket_it)->
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   752
      release_assign_last_node_next(*(b_old_odd->first_ptr()));
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   753
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   754
    b_old_even->redirect();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   755
    b_old_odd->redirect();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   756
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   757
    write_synchonize_on_visible_epoch(thread);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   758
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   759
    // Unlock for writes into new smaller table.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   760
    _new_table->get_bucket(bucket_it)->unlock();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   761
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   762
    DEBUG_ONLY(b_old_even->release_assign_node_ptr(b_old_even->first_ptr(),
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   763
                                                   (Node*)POISON_PTR);)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   764
    DEBUG_ONLY(b_old_odd->release_assign_node_ptr(b_old_odd->first_ptr(),
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   765
                                                  (Node*)POISON_PTR);)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   766
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   767
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   768
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   769
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   770
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   771
  internal_shrink(Thread* thread, size_t log2_size)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   772
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   773
  if (!internal_shrink_prolog(thread, log2_size)) {
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   774
    assert(_resize_lock_owner != thread, "Re-size lock held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   775
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   776
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   777
  assert(_resize_lock_owner == thread, "Should be locked by me");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   778
  internal_shrink_range(thread, 0, _new_table->_size);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   779
  internal_shrink_epilog(thread);
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   780
  assert(_resize_lock_owner != thread, "Re-size lock held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   781
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   782
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   783
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   784
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   785
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   786
  internal_grow_prolog(Thread* thread, size_t log2_size)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   787
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   788
  // This double checking of _size_limit_reached/is_max_size_reached()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   789
  //  we only do in grow path, since grow means high load on table
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   790
  // while shrink means low load.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   791
  if (is_max_size_reached()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   792
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   793
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   794
  if (!try_resize_lock(thread)) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   795
    // Either we have an ongoing resize or an operation which doesn't want us
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   796
    // to resize now.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   797
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   798
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   799
  if (is_max_size_reached() || _table->_log2_size >= log2_size) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   800
    unlock_resize_lock(thread);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   801
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   802
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   803
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   804
  _new_table = new InternalTable(_table->_log2_size + 1);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   805
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   806
  if (_new_table->_log2_size == _log2_size_limit) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   807
    _size_limit_reached = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   808
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   809
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   810
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   811
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   812
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   813
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   814
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   815
  internal_grow_epilog(Thread* thread)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   816
{
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   817
  assert(_resize_lock_owner == thread, "Should be locked");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   818
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   819
  InternalTable* old_table = set_table_from_new();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   820
  unlock_resize_lock(thread);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   821
#ifdef ASSERT
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   822
  for (size_t i = 0; i < old_table->_size; i++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   823
    assert(old_table->get_bucket(i++)->first() == POISON_PTR,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   824
           "No poison found");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   825
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   826
#endif
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   827
  // ABA safe, old_table not visible to any other threads.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   828
  delete old_table;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   829
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   830
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   831
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   832
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   833
  internal_grow(Thread* thread, size_t log2_size)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   834
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   835
  if (!internal_grow_prolog(thread, log2_size)) {
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   836
    assert(_resize_lock_owner != thread, "Re-size lock held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   837
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   838
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   839
  assert(_resize_lock_owner == thread, "Should be locked by me");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   840
  internal_grow_range(thread, 0, _table->_size);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   841
  internal_grow_epilog(thread);
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   842
  assert(_resize_lock_owner != thread, "Re-size lock held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   843
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   844
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   845
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   846
// Always called within critical section
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   847
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   848
template <typename LOOKUP_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   849
inline typename CONFIG::Value* ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   850
  internal_get(Thread* thread, LOOKUP_FUNC& lookup_f, bool* grow_hint)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   851
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   852
  bool clean = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   853
  size_t loops = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   854
  VALUE* ret = NULL;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   855
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   856
  const Bucket* bucket = get_bucket(lookup_f.get_hash());
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   857
  Node* node = get_node(bucket, lookup_f, &clean, &loops);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   858
  if (node != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   859
    ret = node->value();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   860
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   861
  if (grow_hint != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   862
    *grow_hint = loops > _grow_hint;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   863
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   864
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   865
  return ret;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   866
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   867
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   868
template <typename CONFIG, MEMFLAGS F>
52717
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   869
template <typename LOOKUP_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   870
inline bool ConcurrentHashTable<CONFIG, F>::
52717
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   871
  internal_insert(Thread* thread, LOOKUP_FUNC& lookup_f, const VALUE& value,
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   872
                  bool* grow_hint, bool* clean_hint)
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   873
{
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   874
  bool ret = false;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   875
  bool clean = false;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   876
  bool locked;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   877
  size_t loops = 0;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   878
  size_t i = 0;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   879
  uintx hash = lookup_f.get_hash();
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   880
  Node* new_node = Node::create_node(value, NULL);
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   881
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   882
  while (true) {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   883
    {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   884
      ScopedCS cs(thread, this); /* protected the table/bucket */
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   885
      Bucket* bucket = get_bucket(hash);
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   886
      Node* first_at_start = bucket->first();
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   887
      Node* old = get_node(bucket, lookup_f, &clean, &loops);
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   888
      if (old == NULL) {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   889
        new_node->set_next(first_at_start);
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   890
        if (bucket->cas_first(new_node, first_at_start)) {
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
   891
          JFR_ONLY(_stats_rate.add();)
52717
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   892
          new_node = NULL;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   893
          ret = true;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   894
          break; /* leave critical section */
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   895
        }
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   896
        // CAS failed we must leave critical section and retry.
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   897
        locked = bucket->is_locked();
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   898
      } else {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   899
        // There is a duplicate.
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   900
        break; /* leave critical section */
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   901
      }
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   902
    } /* leave critical section */
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   903
    i++;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   904
    if (locked) {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   905
      os::naked_yield();
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   906
    } else {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   907
      SpinPause();
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   908
    }
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   909
  }
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   910
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   911
  if (new_node != NULL) {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   912
    // CAS failed and a duplicate was inserted, we must free this node.
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   913
    Node::destroy_node(new_node);
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   914
  } else if (i == 0 && clean) {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   915
    // We only do cleaning on fast inserts.
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   916
    Bucket* bucket = get_bucket_locked(thread, lookup_f.get_hash());
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   917
    delete_in_bucket(thread, bucket, lookup_f);
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   918
    bucket->unlock();
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   919
    clean = false;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   920
  }
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   921
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   922
  if (grow_hint != NULL) {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   923
    *grow_hint = loops > _grow_hint;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   924
  }
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   925
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   926
  if (clean_hint != NULL) {
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   927
    *clean_hint = clean;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   928
  }
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   929
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   930
  return ret;
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   931
}
b22da519f2e3 8213791: StringTable: Use get and insert
rehn
parents: 52516
diff changeset
   932
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   933
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   934
template <typename FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   935
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   936
  visit_nodes(Bucket* bucket, FUNC& visitor_f)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   937
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   938
  Node* current_node = bucket->first();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   939
  while (current_node != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   940
    if (!visitor_f(current_node->value())) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   941
      return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   942
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   943
    current_node = current_node->next();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   944
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   945
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   946
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   947
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   948
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   949
template <typename FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   950
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   951
  do_scan_locked(Thread* thread, FUNC& scan_f)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   952
{
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   953
  assert(_resize_lock_owner == thread, "Re-size lock not held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   954
  // We can do a critical section over the entire loop but that would block
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   955
  // updates for a long time. Instead we choose to block resizes.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   956
  InternalTable* table = get_table();
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   957
  for (size_t bucket_it = 0; bucket_it < table->_size; bucket_it++) {
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   958
    ScopedCS cs(thread, this);
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
   959
    if (!visit_nodes(table->get_bucket(bucket_it), scan_f)) {
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   960
      break; /* ends critical section */
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   961
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   962
  } /* ends critical section */
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   963
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   964
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   965
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   966
template <typename EVALUATE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   967
inline size_t ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   968
  delete_check_nodes(Bucket* bucket, EVALUATE_FUNC& eval_f,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   969
                     size_t num_del, Node** ndel)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   970
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   971
  size_t dels = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   972
  Node* const volatile * rem_n_prev = bucket->first_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   973
  Node* rem_n = bucket->first();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   974
  while (rem_n != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   975
    if (eval_f(rem_n->value())) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   976
      ndel[dels++] = rem_n;
50958
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   977
      Node* next_node = rem_n->next();
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   978
      bucket->release_assign_node_ptr(rem_n_prev, next_node);
e0028bb6dd3d 8206471: Race with ConcurrentHashTable deleting items on insert with cleanup thread
coleenp
parents: 50637
diff changeset
   979
      rem_n = next_node;
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   980
      if (dels == num_del) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   981
        break;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   982
      }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   983
    } else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   984
      rem_n_prev = rem_n->next_ptr();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   985
      rem_n = rem_n->next();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   986
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   987
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   988
  return dels;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   989
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   990
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   991
// Constructor
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   992
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
   993
inline ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   994
  ConcurrentHashTable(size_t log2size, size_t log2size_limit, size_t grow_hint)
51334
cc2c79d22508 8208671: Runtime, JFR, Serviceability changes to allow enabling -Wreorder
tschatzl
parents: 50958
diff changeset
   995
    : _new_table(NULL), _log2_size_limit(log2size_limit),
cc2c79d22508 8208671: Runtime, JFR, Serviceability changes to allow enabling -Wreorder
tschatzl
parents: 50958
diff changeset
   996
       _log2_start_size(log2size), _grow_hint(grow_hint),
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   997
       _size_limit_reached(false), _resize_lock_owner(NULL),
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   998
       _invisible_epoch(0)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
   999
{
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1000
  _stats_rate = TableRateStatistics();
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1001
  _resize_lock =
58291
a013100f7a35 8213150: Add verification for locking by VMThread
coleenp
parents: 55478
diff changeset
  1002
    new Mutex(Mutex::leaf, "ConcurrentHashTable", true,
a013100f7a35 8213150: Add verification for locking by VMThread
coleenp
parents: 55478
diff changeset
  1003
              Mutex::_safepoint_check_never);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1004
  _table = new InternalTable(log2size);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1005
  assert(log2size_limit >= log2size, "bad ergo");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1006
  _size_limit_reached = _table->_log2_size == _log2_size_limit;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1007
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1008
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1009
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1010
inline ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1011
  ~ConcurrentHashTable()
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1012
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1013
  delete _resize_lock;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1014
  free_nodes();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1015
  delete _table;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1016
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1017
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1018
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1019
inline size_t ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1020
  get_size_log2(Thread* thread)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1021
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1022
  ScopedCS cs(thread, this);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1023
  return _table->_log2_size;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1024
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1025
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1026
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1027
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1028
  shrink(Thread* thread, size_t size_limit_log2)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1029
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1030
  size_t tmp = size_limit_log2 == 0 ? _log2_start_size : size_limit_log2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1031
  bool ret = internal_shrink(thread, tmp);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1032
  return ret;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1033
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1034
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1035
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1036
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1037
  grow(Thread* thread, size_t size_limit_log2)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1038
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1039
  size_t tmp = size_limit_log2 == 0 ? _log2_size_limit : size_limit_log2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1040
  return internal_grow(thread, tmp);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1041
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1042
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1043
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1044
template <typename LOOKUP_FUNC, typename FOUND_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1045
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1046
  get(Thread* thread, LOOKUP_FUNC& lookup_f, FOUND_FUNC& found_f, bool* grow_hint)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1047
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1048
  bool ret = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1049
  ScopedCS cs(thread, this);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1050
  VALUE* val = internal_get(thread, lookup_f, grow_hint);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1051
  if (val != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1052
    found_f(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1053
    ret = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1054
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1055
  return ret;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1056
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1057
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1058
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1059
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1060
  unsafe_insert(const VALUE& value) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1061
  bool dead_hash = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1062
  size_t hash = CONFIG::get_hash(value, &dead_hash);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1063
  if (dead_hash) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1064
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1065
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1066
  // This is an unsafe operation.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1067
  InternalTable* table = get_table();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1068
  Bucket* bucket = get_bucket_in(table, hash);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1069
  assert(!bucket->have_redirect() && !bucket->is_locked(), "bad");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1070
  Node* new_node = Node::create_node(value, bucket->first());
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1071
  if (!bucket->cas_first(new_node, bucket->first())) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1072
    assert(false, "bad");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1073
  }
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1074
  JFR_ONLY(_stats_rate.add();)
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1075
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1076
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1077
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1078
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1079
template <typename SCAN_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1080
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1081
  try_scan(Thread* thread, SCAN_FUNC& scan_f)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1082
{
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1083
  if (!try_resize_lock(thread)) {
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1084
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1085
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1086
  do_scan_locked(thread, scan_f);
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1087
  unlock_resize_lock(thread);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1088
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1089
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1090
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1091
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1092
template <typename SCAN_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1093
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1094
  do_scan(Thread* thread, SCAN_FUNC& scan_f)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1095
{
52516
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1096
  assert(!SafepointSynchronize::is_at_safepoint(),
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1097
         "must be outside a safepoint");
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1098
  assert(_resize_lock_owner != thread, "Re-size lock held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1099
  lock_resize_lock(thread);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1100
  do_scan_locked(thread, scan_f);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1101
  unlock_resize_lock(thread);
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1102
  assert(_resize_lock_owner != thread, "Re-size lock held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1103
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1104
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1105
template <typename CONFIG, MEMFLAGS F>
52516
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1106
template <typename SCAN_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1107
inline void ConcurrentHashTable<CONFIG, F>::
52516
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1108
  do_safepoint_scan(SCAN_FUNC& scan_f)
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1109
{
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1110
  // We only allow this method to be used during a safepoint.
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1111
  assert(SafepointSynchronize::is_at_safepoint(),
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1112
         "must only be called in a safepoint");
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1113
  assert(Thread::current()->is_VM_thread(),
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1114
         "should be in vm thread");
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1115
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1116
  // Here we skip protection,
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1117
  // thus no other thread may use this table at the same time.
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1118
  InternalTable* table = get_table();
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1119
  for (size_t bucket_it = 0; bucket_it < table->_size; bucket_it++) {
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1120
    Bucket* bucket = table->get_bucket(bucket_it);
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1121
    // If bucket have a redirect the items will be in the new table.
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1122
    // We must visit them there since the new table will contain any
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1123
    // concurrent inserts done after this bucket was resized.
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1124
    // If the bucket don't have redirect flag all items is in this table.
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1125
    if (!bucket->have_redirect()) {
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1126
      if(!visit_nodes(bucket, scan_f)) {
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1127
        return;
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1128
      }
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1129
    } else {
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1130
      assert(bucket->is_locked(), "Bucket must be locked.");
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1131
    }
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1132
  }
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1133
  // If there is a paused resize we also need to visit the already resized items.
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1134
  table = get_new_table();
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1135
  if (table == NULL) {
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1136
    return;
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1137
  }
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1138
  DEBUG_ONLY(if (table == POISON_PTR) { return; })
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1139
  for (size_t bucket_it = 0; bucket_it < table->_size; bucket_it++) {
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1140
    Bucket* bucket = table->get_bucket(bucket_it);
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1141
    assert(!bucket->is_locked(), "Bucket must be unlocked.");
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1142
    if (!visit_nodes(bucket, scan_f)) {
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1143
      return;
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1144
    }
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1145
  }
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1146
}
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1147
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1148
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1149
template <typename EVALUATE_FUNC, typename DELETE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1150
inline bool ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1151
  try_bulk_delete(Thread* thread, EVALUATE_FUNC& eval_f, DELETE_FUNC& del_f)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1152
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1153
  if (!try_resize_lock(thread)) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1154
    return false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1155
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1156
  do_bulk_delete_locked(thread, eval_f, del_f);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1157
  unlock_resize_lock(thread);
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1158
  assert(_resize_lock_owner != thread, "Re-size lock held");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1159
  return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1160
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1161
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1162
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1163
template <typename EVALUATE_FUNC, typename DELETE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1164
inline void ConcurrentHashTable<CONFIG, F>::
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1165
  bulk_delete(Thread* thread, EVALUATE_FUNC& eval_f, DELETE_FUNC& del_f)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1166
{
52516
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1167
  assert(!SafepointSynchronize::is_at_safepoint(),
d5eebe1e03fe 8213574: Deadlock in string table expansion when dumping lots of CDS classes
rehn
parents: 52332
diff changeset
  1168
         "must be outside a safepoint");
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1169
  lock_resize_lock(thread);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1170
  do_bulk_delete_locked(thread, eval_f, del_f);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1171
  unlock_resize_lock(thread);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1172
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1173
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1174
template <typename CONFIG, MEMFLAGS F>
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1175
template <typename VALUE_SIZE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1176
inline TableStatistics ConcurrentHashTable<CONFIG, F>::
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1177
  statistics_calculate(Thread* thread, VALUE_SIZE_FUNC& vs_f)
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1178
{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1179
  NumberSeq summary;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1180
  size_t literal_bytes = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1181
  InternalTable* table = get_table();
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1182
  for (size_t bucket_it = 0; bucket_it < table->_size; bucket_it++) {
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1183
    ScopedCS cs(thread, this);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1184
    size_t count = 0;
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1185
    Bucket* bucket = table->get_bucket(bucket_it);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1186
    if (bucket->have_redirect() || bucket->is_locked()) {
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1187
      continue;
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1188
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1189
    Node* current_node = bucket->first();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1190
    while (current_node != NULL) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1191
      ++count;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1192
      literal_bytes += vs_f(current_node->value());
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1193
      current_node = current_node->next();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1194
    }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1195
    summary.add((double)count);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1196
  }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1197
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1198
  return TableStatistics(_stats_rate, summary, literal_bytes, sizeof(Bucket), sizeof(Node));
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1199
}
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1200
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1201
template <typename CONFIG, MEMFLAGS F>
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1202
template <typename VALUE_SIZE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1203
inline TableStatistics ConcurrentHashTable<CONFIG, F>::
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1204
  statistics_get(Thread* thread, VALUE_SIZE_FUNC& vs_f, TableStatistics old)
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1205
{
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1206
  if (!try_resize_lock(thread)) {
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1207
    return old;
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1208
  }
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1209
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1210
  TableStatistics ts = statistics_calculate(thread, vs_f);
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1211
  unlock_resize_lock(thread);
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1212
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1213
  return ts;
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1214
}
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1215
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1216
template <typename CONFIG, MEMFLAGS F>
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1217
template <typename VALUE_SIZE_FUNC>
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1218
inline void ConcurrentHashTable<CONFIG, F>::
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1219
  statistics_to(Thread* thread, VALUE_SIZE_FUNC& vs_f,
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1220
                outputStream* st, const char* table_name)
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1221
{
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1222
  if (!try_resize_lock(thread)) {
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1223
    st->print_cr("statistics unavailable at this moment");
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1224
    return;
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1225
  }
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1226
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1227
  TableStatistics ts = statistics_calculate(thread, vs_f);
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1228
  unlock_resize_lock(thread);
54764
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1229
865ec913f916 8185525: Add JFR event for DictionarySizes
gziemski
parents: 53555
diff changeset
  1230
  ts.print(st, table_name);
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1231
}
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1232
55478
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1233
template <typename CONFIG, MEMFLAGS F>
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1234
inline bool ConcurrentHashTable<CONFIG, F>::
ae2e53e379cb 8214822: Move ConcurrentHashTable VALUE parameter to CONFIG
coleenp
parents: 54764
diff changeset
  1235
  try_move_nodes_to(Thread* thread, ConcurrentHashTable<CONFIG, F>* to_cht)
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1236
{
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1237
  if (!try_resize_lock(thread)) {
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1238
    return false;
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1239
  }
50637
359607017fb7 8205006: Assertion failure when rehashing stringtable
rehn
parents: 50608
diff changeset
  1240
  assert(_new_table == NULL || _new_table == POISON_PTR, "Must be NULL");
50445
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1241
  for (size_t bucket_it = 0; bucket_it < _table->_size; bucket_it++) {
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1242
    Bucket* bucket = _table->get_bucket(bucket_it);
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1243
    assert(!bucket->have_redirect() && !bucket->is_locked(), "Table must be uncontended");
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1244
    while (bucket->first() != NULL) {
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1245
      Node* move_node = bucket->first();
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1246
      bool ok = bucket->cas_first(move_node->next(), move_node);
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1247
      assert(ok, "Uncontended cas must work");
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1248
      bool dead_hash = false;
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1249
      size_t insert_hash = CONFIG::get_hash(*move_node->value(), &dead_hash);
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1250
      if (!dead_hash) {
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1251
        Bucket* insert_bucket = to_cht->get_bucket(insert_hash);
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1252
        assert(!bucket->have_redirect() && !bucket->is_locked(), "Not bit should be present");
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1253
        move_node->set_next(insert_bucket->first());
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1254
        ok = insert_bucket->cas_first(move_node, insert_bucket->first());
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1255
        assert(ok, "Uncontended cas must work");
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1256
      }
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1257
    }
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1258
  }
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1259
  unlock_resize_lock(thread);
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint
rehn
parents: 50429
diff changeset
  1260
  return true;
50158
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1261
}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios
rehn
parents:
diff changeset
  1262
53244
9807daeb47c4 8216167: Update include guards to reflect correct directories
coleenp
parents: 53239
diff changeset
  1263
#endif // SHARE_UTILITIES_CONCURRENTHASHTABLE_INLINE_HPP