jdk-sandbox: test/hotspot/gtest/utilities/test_concurrentHashtable.cpp@cc2c79d22508 (annotated)

50158 8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	1	/*
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	2	* Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.
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	#include "precompiled.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	25	#include "runtime/mutex.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	26	#include "runtime/semaphore.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	27	#include "runtime/thread.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	28	#include "runtime/vmThread.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	29	#include "runtime/vm_operations.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	30	#include "utilities/concurrentHashTable.inline.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	31	#include "utilities/concurrentHashTableTasks.inline.hpp"
51179 516acf6956a2 8207359: Make SymbolTable increment_refcount disallow zero coleenp parents: 50815 diff changeset	32	#include "threadHelper.inline.hpp"
50158 8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	33	#include "unittest.hpp"
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	34
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	35	// NOTE: On win32 gtest asserts are not mt-safe.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	36	// Amusingly as long as they do not assert they are mt-safe.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	37	#define SIZE_32 5
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	38
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	39	struct Pointer;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	40
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	41	typedef ConcurrentHashTable<uintptr_t, Pointer, mtInternal> SimpleTestTable;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	42	typedef ConcurrentHashTable<uintptr_t, Pointer, mtInternal>::MultiGetHandle SimpleTestGetHandle;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	43
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	44	// Simplest working CRPT implementation for the hash-table.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	45	struct Pointer : public SimpleTestTable::BaseConfig {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	46	static uintx get_hash(const uintptr_t& value, bool* dead_hash) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	47	return (uintx)value;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	48	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	49	static const uintptr_t& notfound() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	50	static uintptr_t notfound = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	51	return notfound;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	52	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	53	static void* allocate_node(size_t size, const uintptr_t& value) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	54	return ::malloc(size);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	55	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	56	static void free_node(void* memory, const uintptr_t& value) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	57	::free(memory);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	58	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	59	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	60
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	61	struct SimpleTestLookup {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	62	uintptr_t _val;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	63	SimpleTestLookup(uintptr_t val) : _val(val) {}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	64	uintx get_hash() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	65	return Pointer::get_hash(_val, NULL);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	66	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	67	bool equals(const uintptr_t* value, bool* is_dead) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	68	return _val == *value;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	69	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	70	};
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	static void cht_insert(Thread* thr) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	73	uintptr_t val = 0x2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	74	SimpleTestLookup stl(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	75	SimpleTestTable* cht = new SimpleTestTable();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	76	EXPECT_TRUE(cht->insert(thr, stl, val)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	77	EXPECT_EQ(cht->get_copy(thr, stl), val) << "Getting an existing value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	78	EXPECT_TRUE(cht->remove(thr, stl)) << "Removing an existing value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	79	EXPECT_FALSE(cht->remove(thr, stl)) << "Removing an already removed item succeeded.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	80	EXPECT_NE(cht->get_copy(thr, stl), val) << "Getting a removed value succeeded.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	81	delete cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	82	}
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	struct ValVerify {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	85	uintptr_t _val;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	86	bool called_get;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	87	bool called_insert;
51334 cc2c79d22508 8208671: Runtime, JFR, Serviceability changes to allow enabling -Wreorder tschatzl parents: 51179 diff changeset	88	ValVerify(uintptr_t val) : _val(val), called_get(false), called_insert(false) {}
50158 8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	89	void operator()(bool inserted, uintptr_t* val) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	90	EXPECT_EQ(_val, *val) << "The value inserted is not correct.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	91	if (inserted) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	92	called_insert = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	93	} else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	94	called_get = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	95	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	96	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	97	void verify(bool get, bool insert) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	98	EXPECT_EQ(called_get, get) << "Get unexpected";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	99	EXPECT_EQ(called_insert, insert) << "Insert unexpected";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	100	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	101	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	102
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	103	static void cht_get_insert_helper(Thread* thr, SimpleTestTable* cht, uintptr_t val) {
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	SimpleTestLookup stl(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	106	ValVerify vv(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	107	EXPECT_EQ(cht->get_insert(thr, stl, val, vv), false) << "Inserting an unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	108	vv.verify(false, true);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	109	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	110
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	SimpleTestLookup stl(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	113	ValVerify vv(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	114	EXPECT_EQ(cht->get_insert(thr, stl, val, vv), true) << "Getting an old value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	115	vv.verify(true, false);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	116	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	117	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	118
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	119	static void cht_get_insert(Thread* thr) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	120	uintptr_t val = 0x2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	121	SimpleTestLookup stl(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	122	SimpleTestTable* cht = new SimpleTestTable();
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	SCOPED_TRACE("First");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	126	cht_get_insert_helper(thr, cht, val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	127	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	128	EXPECT_EQ(cht->get_copy(thr, stl), val) << "Get an old value failed";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	129	EXPECT_TRUE(cht->remove(thr, stl)) << "Removing existing value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	130	EXPECT_NE(cht->get_copy(thr, stl), val) << "Got an already removed item.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	131
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	132	{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	133	SCOPED_TRACE("Second");
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	134	cht_get_insert_helper(thr, cht, val);
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	137	delete cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	138	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	139
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	140	static bool getinsert_bulkdelete_eval(uintptr_t* val) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	141	EXPECT_TRUE(val > 0 && val < 4) << "Val wrong for this test.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	142	return (*val & 0x1); // Delete all values ending with first bit set.
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	static void getinsert_bulkdelete_del(uintptr_t* val) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	146	EXPECT_EQ(*val & 0x1, (uintptr_t)1) << "Deleting wrong value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	147	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	148
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	149	static void cht_getinsert_bulkdelete_insert_verified(Thread* thr, SimpleTestTable* cht, uintptr_t val,
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	150	bool verify_expect_get, bool verify_expect_inserted) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	151	ValVerify vv(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	152	SimpleTestLookup stl(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	153	EXPECT_EQ(cht->get_insert(thr, stl, val, vv), verify_expect_get) << "Inserting an unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	154	vv.verify(verify_expect_get, verify_expect_inserted);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	155	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	156
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	157	static void cht_getinsert_bulkdelete(Thread* thr) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	158	uintptr_t val1 = 1;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	159	uintptr_t val2 = 2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	160	uintptr_t val3 = 3;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	161	SimpleTestLookup stl1(val1), stl2(val2), stl3(val3);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	162
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	163	SimpleTestTable* cht = new SimpleTestTable();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	164	cht_getinsert_bulkdelete_insert_verified(thr, cht, val1, false, true);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	165	cht_getinsert_bulkdelete_insert_verified(thr, cht, val2, false, true);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	166	cht_getinsert_bulkdelete_insert_verified(thr, cht, val3, false, true);
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	EXPECT_TRUE(cht->remove(thr, stl2)) << "Remove did not find value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	169
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	170	cht_getinsert_bulkdelete_insert_verified(thr, cht, val1, true, false); // val1 should be present
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	171	cht_getinsert_bulkdelete_insert_verified(thr, cht, val2, false, true); // val2 should be inserted
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	172	cht_getinsert_bulkdelete_insert_verified(thr, cht, val3, true, false); // val3 should be present
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	173
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	174	EXPECT_EQ(cht->get_copy(thr, stl1), val1) << "Get did not find value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	175	EXPECT_EQ(cht->get_copy(thr, stl2), val2) << "Get did not find value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	176	EXPECT_EQ(cht->get_copy(thr, stl3), val3) << "Get did not find value.";
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	// Removes all odd values.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	179	cht->bulk_delete(thr, getinsert_bulkdelete_eval, getinsert_bulkdelete_del);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	180
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	181	EXPECT_EQ(cht->get_copy(thr, stl1), (uintptr_t)0) << "Odd value should not exist.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	182	EXPECT_FALSE(cht->remove(thr, stl1)) << "Odd value should not exist.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	183	EXPECT_EQ(cht->get_copy(thr, stl2), val2) << "Even value should not have been removed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	184	EXPECT_EQ(cht->get_copy(thr, stl3), (uintptr_t)0) << "Add value should not exists.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	185	EXPECT_FALSE(cht->remove(thr, stl3)) << "Odd value should not exists.";
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	delete cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	188	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	189
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	190	static void cht_getinsert_bulkdelete_task(Thread* thr) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	191	uintptr_t val1 = 1;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	192	uintptr_t val2 = 2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	193	uintptr_t val3 = 3;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	194	SimpleTestLookup stl1(val1), stl2(val2), stl3(val3);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	195
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	196	SimpleTestTable* cht = new SimpleTestTable();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	197	cht_getinsert_bulkdelete_insert_verified(thr, cht, val1, false, true);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	198	cht_getinsert_bulkdelete_insert_verified(thr, cht, val2, false, true);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	199	cht_getinsert_bulkdelete_insert_verified(thr, cht, val3, false, true);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	200
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	201	EXPECT_TRUE(cht->remove(thr, stl2)) << "Remove did not find value.";
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	cht_getinsert_bulkdelete_insert_verified(thr, cht, val1, true, false); // val1 should be present
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	204	cht_getinsert_bulkdelete_insert_verified(thr, cht, val2, false, true); // val2 should be inserted
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	205	cht_getinsert_bulkdelete_insert_verified(thr, cht, val3, true, false); // val3 should be present
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	206
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	207	EXPECT_EQ(cht->get_copy(thr, stl1), val1) << "Get did not find value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	208	EXPECT_EQ(cht->get_copy(thr, stl2), val2) << "Get did not find value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	209	EXPECT_EQ(cht->get_copy(thr, stl3), val3) << "Get did not find value.";
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	// Removes all odd values.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	212	SimpleTestTable::BulkDeleteTask bdt(cht);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	213	if (bdt.prepare(thr)) {
50608 1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	214	while(bdt.do_task(thr, getinsert_bulkdelete_eval, getinsert_bulkdelete_del)) {
50158 8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	215	bdt.pause(thr);
50815 54a285a5c6cb 8205583: Crash in ConcurrentHashTable do_bulk_delete_locked_for rehn parents: 50608 diff changeset	216	bdt.cont(thr);
50158 8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	217	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	218	bdt.done(thr);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	219	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	220
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	221	EXPECT_EQ(cht->get_copy(thr, stl1), (uintptr_t)0) << "Odd value should not exist.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	222	EXPECT_FALSE(cht->remove(thr, stl1)) << "Odd value should not exist.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	223	EXPECT_EQ(cht->get_copy(thr, stl2), val2) << "Even value should not have been removed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	224	EXPECT_EQ(cht->get_copy(thr, stl3), (uintptr_t)0) << "Add value should not exists.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	225	EXPECT_FALSE(cht->remove(thr, stl3)) << "Odd value should not exists.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	226
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	227	delete cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	228	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	229
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	230	static void cht_scope(Thread* thr) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	231	uintptr_t val = 0x2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	232	SimpleTestLookup stl(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	233	SimpleTestTable* cht = new SimpleTestTable();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	234	EXPECT_TRUE(cht->insert(thr, stl, val)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	235	{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	236	SimpleTestGetHandle get_handle(thr, cht);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	237	EXPECT_EQ(*get_handle.get(stl), val) << "Getting a pre-existing value failed.";
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	// We do remove here to make sure the value-handle 'unlocked' the table when leaving the scope.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	240	EXPECT_TRUE(cht->remove(thr, stl)) << "Removing a pre-existing value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	241	EXPECT_FALSE(cht->get_copy(thr, stl) == val) << "Got a removed value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	242	delete cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	243	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	244
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	245	struct ChtScan {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	246	size_t _count;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	247	ChtScan() : _count(0) {}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	248	bool operator()(uintptr_t* val) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	249	EXPECT_EQ(*val, (uintptr_t)0x2) << "Got an unknown value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	250	EXPECT_EQ(_count, 0u) << "Only one value should be in table.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	251	_count++;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	252	return true; /* continue scan */
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	253	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	254	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	255
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	256	static void cht_scan(Thread* thr) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	257	uintptr_t val = 0x2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	258	SimpleTestLookup stl(val);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	259	ChtScan scan;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	260	SimpleTestTable* cht = new SimpleTestTable();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	261	EXPECT_TRUE(cht->insert(thr, stl, val)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	262	EXPECT_EQ(cht->try_scan(thr, scan), true) << "Scanning an non-growing/shrinking table should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	263	EXPECT_TRUE(cht->remove(thr, stl)) << "Removing a pre-existing value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	264	EXPECT_FALSE(cht->get_copy(thr, stl) == val) << "Got a removed value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	265	delete cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	266	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	267
50445 bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	268	struct ChtCountScan {
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	269	size_t _count;
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	270	ChtCountScan() : _count(0) {}
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	271	bool operator()(uintptr_t* val) {
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	272	_count++;
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	273	return true; /* continue scan */
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	274	}
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	275	};
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	276
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	277	static void cht_move_to(Thread* thr) {
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	278	uintptr_t val1 = 0x2;
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	279	uintptr_t val2 = 0xe0000002;
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	280	uintptr_t val3 = 0x3;
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	281	SimpleTestLookup stl1(val1), stl2(val2), stl3(val3);
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	282	SimpleTestTable* from_cht = new SimpleTestTable();
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	283	EXPECT_TRUE(from_cht->insert(thr, stl1, val1)) << "Insert unique value failed.";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	284	EXPECT_TRUE(from_cht->insert(thr, stl2, val2)) << "Insert unique value failed.";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	285	EXPECT_TRUE(from_cht->insert(thr, stl3, val3)) << "Insert unique value failed.";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	286
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	287	SimpleTestTable* to_cht = new SimpleTestTable();
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	288	EXPECT_TRUE(from_cht->try_move_nodes_to(thr, to_cht)) << "Moving nodes to new table failed";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	289
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	290	ChtCountScan scan_old;
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	291	EXPECT_TRUE(from_cht->try_scan(thr, scan_old)) << "Scanning table should work.";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	292	EXPECT_EQ(scan_old._count, (size_t)0) << "All items should be moved";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	293
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	294	ChtCountScan scan_new;
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	295	EXPECT_TRUE(to_cht->try_scan(thr, scan_new)) << "Scanning table should work.";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	296	EXPECT_EQ(scan_new._count, (size_t)3) << "All items should be moved";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	297	EXPECT_TRUE(to_cht->get_copy(thr, stl1) == val1) << "Getting an inserted value should work.";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	298	EXPECT_TRUE(to_cht->get_copy(thr, stl2) == val2) << "Getting an inserted value should work.";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	299	EXPECT_TRUE(to_cht->get_copy(thr, stl3) == val3) << "Getting an inserted value should work.";
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	300	}
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	301
50158 8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	302	static void cht_grow(Thread* thr) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	303	uintptr_t val = 0x2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	304	uintptr_t val2 = 0x22;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	305	uintptr_t val3 = 0x222;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	306	SimpleTestLookup stl(val), stl2(val2), stl3(val3);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	307	SimpleTestTable* cht = new SimpleTestTable();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	308
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	309	EXPECT_TRUE(cht->insert(thr, stl, val)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	310	EXPECT_TRUE(cht->insert(thr, stl2, val2)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	311	EXPECT_TRUE(cht->insert(thr, stl3, val3)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	312	EXPECT_FALSE(cht->insert(thr, stl3, val3)) << "Insert duplicate value should have failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	313	EXPECT_TRUE(cht->get_copy(thr, stl) == val) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	314	EXPECT_TRUE(cht->get_copy(thr, stl2) == val2) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	315	EXPECT_TRUE(cht->get_copy(thr, stl3) == val3) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	316
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	317	EXPECT_TRUE(cht->remove(thr, stl2)) << "Removing an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	318
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	319	EXPECT_TRUE(cht->get_copy(thr, stl) == val) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	320	EXPECT_FALSE(cht->get_copy(thr, stl2) == val2) << "Getting a removed value should have failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	321	EXPECT_TRUE(cht->get_copy(thr, stl3) == val3) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	322
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	323
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	324	EXPECT_TRUE(cht->grow(thr)) << "Growing uncontended should not fail.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	325
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	326	EXPECT_TRUE(cht->get_copy(thr, stl) == val) << "Getting an item after grow failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	327	EXPECT_FALSE(cht->get_copy(thr, stl2) == val2) << "Getting a removed value after grow should have failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	328	EXPECT_TRUE(cht->get_copy(thr, stl3) == val3) << "Getting an item after grow failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	329
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	330	EXPECT_TRUE(cht->insert(thr, stl2, val2)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	331	EXPECT_TRUE(cht->remove(thr, stl3)) << "Removing an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	332
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	333	EXPECT_TRUE(cht->shrink(thr)) << "Shrinking uncontended should not fail.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	334
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	335	EXPECT_TRUE(cht->get_copy(thr, stl) == val) << "Getting an item after shrink failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	336	EXPECT_TRUE(cht->get_copy(thr, stl2) == val2) << "Getting an item after shrink failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	337	EXPECT_FALSE(cht->get_copy(thr, stl3) == val3) << "Getting a removed value after shrink should have failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	338
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	339	delete cht;
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	342	static void cht_task_grow(Thread* thr) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	343	uintptr_t val = 0x2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	344	uintptr_t val2 = 0x22;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	345	uintptr_t val3 = 0x222;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	346	SimpleTestLookup stl(val), stl2(val2), stl3(val3);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	347	SimpleTestTable* cht = new SimpleTestTable();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	348
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	349	EXPECT_TRUE(cht->insert(thr, stl, val)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	350	EXPECT_TRUE(cht->insert(thr, stl2, val2)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	351	EXPECT_TRUE(cht->insert(thr, stl3, val3)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	352	EXPECT_FALSE(cht->insert(thr, stl3, val3)) << "Insert duplicate value should have failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	353	EXPECT_TRUE(cht->get_copy(thr, stl) == val) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	354	EXPECT_TRUE(cht->get_copy(thr, stl2) == val2) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	355	EXPECT_TRUE(cht->get_copy(thr, stl3) == val3) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	356
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	357	EXPECT_TRUE(cht->remove(thr, stl2)) << "Removing an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	358
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	359	EXPECT_TRUE(cht->get_copy(thr, stl) == val) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	360	EXPECT_FALSE(cht->get_copy(thr, stl2) == val2) << "Getting a removed value should have failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	361	EXPECT_TRUE(cht->get_copy(thr, stl3) == val3) << "Getting an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	362
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	363	SimpleTestTable::GrowTask gt(cht);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	364	EXPECT_TRUE(gt.prepare(thr)) << "Growing uncontended should not fail.";
50608 1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	365	while(gt.do_task(thr)) { /* grow */ }
50158 8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	366	gt.done(thr);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	367
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	368	EXPECT_TRUE(cht->get_copy(thr, stl) == val) << "Getting an item after grow failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	369	EXPECT_FALSE(cht->get_copy(thr, stl2) == val2) << "Getting a removed value after grow should have failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	370	EXPECT_TRUE(cht->get_copy(thr, stl3) == val3) << "Getting an item after grow failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	371
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	372	EXPECT_TRUE(cht->insert(thr, stl2, val2)) << "Insert unique value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	373	EXPECT_TRUE(cht->remove(thr, stl3)) << "Removing an inserted value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	374
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	375	EXPECT_TRUE(cht->shrink(thr)) << "Shrinking uncontended should not fail.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	376
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	377	EXPECT_TRUE(cht->get_copy(thr, stl) == val) << "Getting an item after shrink failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	378	EXPECT_TRUE(cht->get_copy(thr, stl2) == val2) << "Getting an item after shrink failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	379	EXPECT_FALSE(cht->get_copy(thr, stl3) == val3) << "Getting a removed value after shrink should have failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	380
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	381	delete cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	382	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	383
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	384	TEST_VM(ConcurrentHashTable, basic_insert) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	385	nomt_test_doer(cht_insert);
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	388	TEST_VM(ConcurrentHashTable, basic_get_insert) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	389	nomt_test_doer(cht_get_insert);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	390	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	391
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	392	TEST_VM(ConcurrentHashTable, basic_scope) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	393	nomt_test_doer(cht_scope);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	394	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	395
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	396	TEST_VM(ConcurrentHashTable, basic_get_insert_bulk_delete) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	397	nomt_test_doer(cht_getinsert_bulkdelete);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	398	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	399
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	400	TEST_VM(ConcurrentHashTable, basic_get_insert_bulk_delete_task) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	401	nomt_test_doer(cht_getinsert_bulkdelete_task);
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	404	TEST_VM(ConcurrentHashTable, basic_scan) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	405	nomt_test_doer(cht_scan);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	406	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	407
50445 bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	408	TEST_VM(ConcurrentHashTable, basic_move_to) {
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	409	nomt_test_doer(cht_move_to);
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	410	}
bd6b78feb6a3 8195097: Make it possible to process StringTable outside safepoint rehn parents: 50158 diff changeset	411
50158 8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	412	TEST_VM(ConcurrentHashTable, basic_grow) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	413	nomt_test_doer(cht_grow);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	414	}
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	TEST_VM(ConcurrentHashTable, task_grow) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	417	nomt_test_doer(cht_task_grow);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	418	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	419
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	420	//#############################################################################################
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	class TestInterface;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	423
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	424	typedef ConcurrentHashTable<uintptr_t, TestInterface, mtInternal> TestTable;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	425	typedef ConcurrentHashTable<uintptr_t, TestInterface, mtInternal>::MultiGetHandle TestGetHandle;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	426
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	427	class TestInterface : public TestTable::BaseConfig {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	428	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	429	static uintx get_hash(const uintptr_t& value, bool* dead_hash) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	430	return (uintx)(value + 18446744073709551557ul) * 18446744073709551557ul;
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	static const uintptr_t& notfound() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	433	static uintptr_t notfound = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	434	return notfound;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	435	}
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	438	struct TestLookup {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	439	uintptr_t _val;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	440	TestLookup(uintptr_t val) : _val(val) {}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	441	uintx get_hash() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	442	return TestInterface::get_hash(_val, NULL);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	443	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	444	bool equals(const uintptr_t* value, bool* is_dead) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	445	return _val == *value;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	446	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	447	};
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	class CHTTestThread : public JavaTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	450	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	451	uintptr_t _start;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	452	uintptr_t _stop;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	453	TestTable *_cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	454	jlong _stop_ms;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	455	CHTTestThread(uintptr_t start, uintptr_t stop, TestTable* cht, Semaphore* post)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	456	: JavaTestThread(post), _start(start), _stop(stop), _cht(cht) {}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	457	virtual void premain() {}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	458	void main_run() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	459	premain();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	460	_stop_ms = os::javaTimeMillis() + 2000; // 2 seconds max test time
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	461	while (keep_looping() && test_loop()) { /* */ }
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	462	postmain();
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	virtual void postmain() {}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	465	virtual bool keep_looping() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	466	return _stop_ms > os::javaTimeMillis();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	467	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	468	virtual bool test_loop() = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	469	virtual ~CHTTestThread() {}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	470	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	471
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	472	class ValueSaver {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	473	uintptr_t* _vals;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	474	size_t _it;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	475	size_t _size;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	476	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	477	ValueSaver() : _it(0), _size(1024) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	478	_vals = NEW_C_HEAP_ARRAY(uintptr_t, _size, mtInternal);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	479	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	480
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	481	bool operator()(uintptr_t* val) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	482	_vals[_it++] = *val;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	483	if (_it == _size) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	484	_size *= 2;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	485	_vals = REALLOC_RESOURCE_ARRAY(uintptr_t, _vals, _size/2, _size);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	486	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	487	return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	488	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	489
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	490	void check() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	491	for (size_t i = 0; i < _it; i++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	492	size_t count = 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	493	for (size_t j = (i + 1u); j < _it; j++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	494	if (_vals[i] == _vals[j]) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	495	count++;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	496	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	497	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	498	EXPECT_EQ(count, 0u);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	499	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	500	}
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	503	static void integrity_check(Thread* thr, TestTable* cht)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	504	{
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	505	ValueSaver vs;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	506	cht->do_scan(thr, vs);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	507	vs.check();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	508	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	509
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	510	//#############################################################################################
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	511	// All threads are working on different items
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	512	// This item should only be delete by this thread
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	513	// Thus get_unsafe is safe for this test.
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	514
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	515	class SimpleInserterThread : public CHTTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	516	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	517	static volatile bool _exit;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	518
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	519	SimpleInserterThread(uintptr_t start, uintptr_t stop, TestTable* cht, Semaphore* post)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	520	: CHTTestThread(start, stop, cht, post) {};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	521	virtual ~SimpleInserterThread(){}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	522
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	523	bool keep_looping() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	524	return !_exit;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	525	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	526
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	527	bool test_loop() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	528	bool grow;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	529	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	530	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	531	EXPECT_TRUE(_cht->insert(this, tl, v, &grow)) << "Inserting an unique value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	532	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	533	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	534	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	535	EXPECT_TRUE(_cht->get_copy(this, tl) == v) << "Getting an previously inserted value unsafe failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	536	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	537	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	538	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	539	EXPECT_TRUE(_cht->remove(this, tl)) << "Removing an existing value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	540	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	541	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	542	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	543	EXPECT_TRUE(_cht->get_copy(this, tl) == TestInterface::notfound()) << "Got a removed value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	544	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	545	return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	546	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	547	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	548
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	549	volatile bool SimpleInserterThread::_exit = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	550
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	551	class RunnerSimpleInserterThread : public CHTTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	552	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	553	Semaphore _done;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	554
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	555	RunnerSimpleInserterThread(Semaphore* post) : CHTTestThread(0, 0, NULL, post) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	556	_cht = new TestTable(SIZE_32, SIZE_32);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	557	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	558	virtual ~RunnerSimpleInserterThread(){}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	559
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	560	void premain() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	561
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	562	SimpleInserterThread* ins1 = new SimpleInserterThread((uintptr_t)0x100, (uintptr_t) 0x1FF, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	563	SimpleInserterThread* ins2 = new SimpleInserterThread((uintptr_t)0x200, (uintptr_t) 0x2FF, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	564	SimpleInserterThread* ins3 = new SimpleInserterThread((uintptr_t)0x300, (uintptr_t) 0x3FF, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	565	SimpleInserterThread* ins4 = new SimpleInserterThread((uintptr_t)0x400, (uintptr_t) 0x4FF, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	566
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	567	for (uintptr_t v = 0x500; v < 0x5FF; v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	568	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	569	EXPECT_TRUE(_cht->insert(this, tl, v)) << "Inserting an unique value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	570	}
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	ins1->doit();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	573	ins2->doit();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	574	ins3->doit();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	575	ins4->doit();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	576
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	579	bool test_loop() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	580	for (uintptr_t v = 0x500; v < 0x5FF; v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	581	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	582	EXPECT_TRUE(_cht->get_copy(this, tl) == v) << "Getting an previously inserted value unsafe failed.";;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	583	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	584	return true;
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	587	void postmain() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	588	SimpleInserterThread::_exit = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	589	for (int i = 0; i < 4; i++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	590	_done.wait();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	591	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	592	for (uintptr_t v = 0x500; v < 0x5FF; v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	593	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	594	EXPECT_TRUE(_cht->remove(this, tl)) << "Removing an existing value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	595	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	596	integrity_check(this, _cht);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	597	delete _cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	598	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	599	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	600
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	601
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	602	TEST_VM(ConcurrentHashTable, concurrent_simple) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	603	SimpleInserterThread::_exit = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	604	mt_test_doer<RunnerSimpleInserterThread>();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	605	}
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	// In this test we try to get a 'bad' value
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	609	class DeleteInserterThread : public CHTTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	610	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	611	static volatile bool _exit;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	612
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	613	DeleteInserterThread(uintptr_t start, uintptr_t stop, TestTable* cht, Semaphore* post) : CHTTestThread(start, stop, cht, post) {};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	614	virtual ~DeleteInserterThread(){}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	615
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	616	bool keep_looping() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	617	return !_exit;
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	620	bool test_loop() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	621	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	622	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	623	_cht->insert(this, tl, v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	624	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	625	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	626	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	627	_cht->remove(this, tl);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	628	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	629	return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	630	}
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	633	volatile bool DeleteInserterThread::_exit = true;
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	class RunnerDeleteInserterThread : public CHTTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	636	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	637	Semaphore _done;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	638
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	639	RunnerDeleteInserterThread(Semaphore* post) : CHTTestThread(0, 0, NULL, post) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	640	_cht = new TestTable(SIZE_32, SIZE_32);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	641	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	642	virtual ~RunnerDeleteInserterThread(){}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	643
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	644	void premain() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	645	DeleteInserterThread* ins1 = new DeleteInserterThread((uintptr_t)0x1, (uintptr_t) 0xFFF, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	646	DeleteInserterThread* ins2 = new DeleteInserterThread((uintptr_t)0x1, (uintptr_t) 0xFFF, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	647	DeleteInserterThread* ins3 = new DeleteInserterThread((uintptr_t)0x1, (uintptr_t) 0xFFF, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	648	DeleteInserterThread* ins4 = new DeleteInserterThread((uintptr_t)0x1, (uintptr_t) 0xFFF, _cht, &_done);
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	ins1->doit();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	651	ins2->doit();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	652	ins3->doit();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	653	ins4->doit();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	654	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	655
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	656	bool test_loop() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	657	for (uintptr_t v = 0x1; v < 0xFFF; v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	658	uintptr_t tv;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	659	if (v & 0x1) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	660	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	661	tv = _cht->get_copy(this, tl);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	662	} else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	663	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	664	TestGetHandle value_handle(this, _cht);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	665	uintptr_t* tmp = value_handle.get(tl);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	666	tv = tmp != NULL ? *tmp : 0;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	667	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	668	EXPECT_TRUE(tv == 0 \|\| tv == v) << "Got unknown value.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	669	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	670	return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	671	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	672
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	673	void postmain() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	674	DeleteInserterThread::_exit = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	675	for (int i = 0; i < 4; i++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	676	_done.wait();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	677	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	678	integrity_check(this, _cht);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	679	delete _cht;
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	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	682
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	683	TEST_VM(ConcurrentHashTable, concurrent_deletes) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	684	DeleteInserterThread::_exit = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	685	mt_test_doer<RunnerDeleteInserterThread>();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	686	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	687
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	688	//#############################################################################################
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	689
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	690	#define START_SIZE 13
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	691	#define END_SIZE 17
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	692	#define START (uintptr_t)0x10000
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	693	#define RANGE (uintptr_t)0xFFFF
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	#define GSTEST_THREAD_COUNT 5
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	696
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	697
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	698	class GSInserterThread: public CHTTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	699	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	700	static volatile bool _shrink;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	701	GSInserterThread(uintptr_t start, uintptr_t stop, TestTable* cht, Semaphore* post) : CHTTestThread(start, stop, cht, post) {};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	702	virtual ~GSInserterThread(){}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	703	bool keep_looping() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	704	return !(_shrink && _cht->get_size_log2(this) == START_SIZE);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	705	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	706	bool test_loop() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	707	bool grow;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	708	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	709	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	710	EXPECT_TRUE(_cht->insert(this, tl, v, &grow)) << "Inserting an unique value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	711	if (grow && !_shrink) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	712	_cht->grow(this);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	713	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	714	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	715	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	716	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	717	EXPECT_TRUE(_cht->get_copy(this, tl) == v) << "Getting an previously inserted value unsafe failed.";
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	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	720	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	721	EXPECT_TRUE(_cht->remove(this, tl)) << "Removing an existing value failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	722	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	723	if (_shrink) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	724	_cht->shrink(this);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	725	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	726	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	727	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	728	EXPECT_FALSE(_cht->get_copy(this, tl) == v) << "Getting a removed value should have failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	729	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	730	if (!_shrink && _cht->get_size_log2(this) == END_SIZE) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	731	_shrink = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	732	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	733	return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	734	}
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	737	volatile bool GSInserterThread::_shrink = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	738
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	739	class GSScannerThread : public CHTTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	740	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	741	GSScannerThread(uintptr_t start, uintptr_t stop, TestTable* cht, Semaphore* post) : CHTTestThread(start, stop, cht, post) {};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	742	virtual ~GSScannerThread(){}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	743
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	744	bool operator()(uintptr_t* val) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	745	if (val >= this->_start && val <= this->_stop) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	746	return false;
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	// continue scan
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	749	return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	750	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	751
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	752	bool test_loop() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	753	_cht->try_scan(this, *this);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	754	os::naked_short_sleep(5);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	755	return true;
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	};
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	class RunnerGSInserterThread : public CHTTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	760	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	761	uintptr_t _start;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	762	uintptr_t _range;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	763	Semaphore _done;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	764
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	765	RunnerGSInserterThread(Semaphore* post) : CHTTestThread(0, 0, NULL, post) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	766	_cht = new TestTable(START_SIZE, END_SIZE, 2);
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	virtual ~RunnerGSInserterThread(){}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	769
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	770	void premain() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	771	volatile bool timeout = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	772	_start = START;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	773	_range = RANGE;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	774	CHTTestThread* tt[GSTEST_THREAD_COUNT];
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	775	tt[0] = new GSInserterThread(_start, _start + _range, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	776	_start += _range + 1;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	777	tt[1] = new GSInserterThread(_start, _start + _range, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	778	_start += _range + 1;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	779	tt[2] = new GSInserterThread(_start, _start + _range, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	780	_start += _range + 1;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	781	tt[3] = new GSInserterThread(_start, _start + _range, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	782	tt[4] = new GSScannerThread(_start, _start + _range, _cht, &_done);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	783	_start += _range + 1;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	784
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	785
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	786	for (uintptr_t v = _start; v <= (_start + _range); v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	787	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	788	EXPECT_TRUE(_cht->insert(this, tl, v)) << "Inserting an unique value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	789	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	790
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	791	for (int i = 0; i < GSTEST_THREAD_COUNT; i++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	792	tt[i]->doit();
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	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	795
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	796	bool test_loop() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	797	for (uintptr_t v = _start; v <= (_start + _range); v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	798	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	799	EXPECT_TRUE(_cht->get_copy(this, tl) == v) << "Getting an previously inserted value unsafe failed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	800	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	801	return true;
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	void postmain() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	805	GSInserterThread::_shrink = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	806	for (uintptr_t v = _start; v <= (_start + _range); v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	807	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	808	EXPECT_TRUE(_cht->remove(this, tl)) << "Removing an existing value failed.";
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	for (int i = 0; i < GSTEST_THREAD_COUNT; i++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	811	_done.wait();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	812	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	813	EXPECT_TRUE(_cht->get_size_log2(this) == START_SIZE) << "Not at start size.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	814	Count cnt;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	815	_cht->do_scan(this, cnt);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	816	EXPECT_TRUE(cnt._cnt == 0) << "Items still in table";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	817	delete _cht;
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	820	struct Count {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	821	Count() : _cnt(0) {}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	822	size_t _cnt;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	823	bool operator()(uintptr_t*) { _cnt++; return true; };
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	824	};
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
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	827	TEST_VM(ConcurrentHashTable, concurrent_scan_grow_shrink) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	828	GSInserterThread::_shrink = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	829	mt_test_doer<RunnerGSInserterThread>();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	830	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	831
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	832
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	833	//#############################################################################################
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	#define GI_BD_GI_BD_START_SIZE 13
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	836	#define GI_BD_END_SIZE 17
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	837	#define GI_BD_START (uintptr_t)0x1
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	838	#define GI_BD_RANGE (uintptr_t)0x3FFFF
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	839
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	840	#define GI_BD_TEST_THREAD_COUNT 4
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	841
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	842
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	843	class GI_BD_InserterThread: public CHTTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	844	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	845	static volatile bool _shrink;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	846	uintptr_t _br;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	847	GI_BD_InserterThread(uintptr_t start, uintptr_t stop, TestTable* cht, Semaphore* post, uintptr_t br)
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	848	: CHTTestThread(start, stop, cht, post), _br(br) {};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	849	virtual ~GI_BD_InserterThread(){}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	850
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	851	bool keep_looping() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	852	return !(_shrink && _cht->get_size_log2(this) == GI_BD_GI_BD_START_SIZE);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	853	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	854
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	855	bool test_loop() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	856	bool grow;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	857	MyDel del(_br);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	858	for (uintptr_t v = _start; v <= _stop; v++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	859	ValVerify vv(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	860	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	861	_cht->get_insert(this, tl, v, vv, &grow);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	862	EXPECT_NE(vv.called_get, vv.called_insert) << "Non or both callbacks was called.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	863	if (grow && !_shrink) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	864	_cht->grow(this);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	865	}
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	if (_shrink) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	868	_cht->shrink(this);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	869	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	870	_cht->try_bulk_delete(this, *this, del);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	871	if (!_shrink && _cht->is_max_size_reached()) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	872	_shrink = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	873	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	874	_cht->bulk_delete(this, *this, del);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	875	return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	876	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	877
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	878	bool operator()(uintptr_t* val) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	879	return (*val & _br) == 1;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	880	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	881
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	882	struct MyDel {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	883	MyDel(uintptr_t &br) : _br(br) {};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	884	uintptr_t &_br;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	885	void operator()(uintptr_t* val) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	886	EXPECT_EQ((*val & _br), _br) << "Removing an item that should not have been removed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	887	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	888	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	889	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	890
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	891	volatile bool GI_BD_InserterThread::_shrink = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	892
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	893	class RunnerGI_BD_InserterThread : public CHTTestThread {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	894	public:
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	895	Semaphore _done;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	896	uintptr_t _start;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	897	uintptr_t _range;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	898	RunnerGI_BD_InserterThread(Semaphore* post) : CHTTestThread(0, 0, NULL, post) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	899	_cht = new TestTable(GI_BD_GI_BD_START_SIZE, GI_BD_END_SIZE, 2);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	900	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	901	virtual ~RunnerGI_BD_InserterThread(){}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	902
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	903	void premain() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	904	_start = GI_BD_START;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	905	_range = GI_BD_RANGE;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	906	CHTTestThread* tt[GI_BD_TEST_THREAD_COUNT];
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	907	tt[0] = new GI_BD_InserterThread(_start, _start + _range, _cht, &_done, (uintptr_t)0x1);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	908	tt[1] = new GI_BD_InserterThread(_start, _start + _range, _cht, &_done, (uintptr_t)0x2);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	909	tt[2] = new GI_BD_InserterThread(_start, _start + _range, _cht, &_done, (uintptr_t)0x4);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	910	tt[3] = new GI_BD_InserterThread(_start, _start + _range, _cht, &_done, (uintptr_t)0x8);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	911
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	912	for (uintptr_t v = _start; v <= (_start + _range); v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	913	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	914	EXPECT_TRUE(_cht->insert(this, tl, v)) << "Inserting an unique value should work.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	915	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	916
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	917	for (int i =0; i < GI_BD_TEST_THREAD_COUNT; i++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	918	tt[i]->doit();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	919	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	920	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	921
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	922	bool test_loop() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	923	for (uintptr_t v = _start; v <= (_start + _range); v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	924	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	925	if (v & 0xF) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	926	_cht->get_copy(this, tl);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	927	} else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	928	EXPECT_EQ(_cht->get_copy(this, tl), v) << "Item ending with 0xX0 should never be removed.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	929	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	930	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	931	return true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	932	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	933
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	934	void postmain() {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	935	GI_BD_InserterThread::_shrink = true;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	936	for (uintptr_t v = _start; v <= (_start + _range); v++ ) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	937	TestLookup tl(v);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	938	if (v & 0xF) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	939	_cht->remove(this, tl);
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	940	} else {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	941	EXPECT_TRUE(_cht->remove(this, tl)) << "Removing item ending with 0xX0 should always work.";
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	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	944	for (int i = 0; i < GI_BD_TEST_THREAD_COUNT; i++) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	945	_done.wait();
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	EXPECT_TRUE(_cht->get_size_log2(this) == GI_BD_GI_BD_START_SIZE) << "We have not shrunk back to start size.";
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	948	delete _cht;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	949	}
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	950	};
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	951
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	952	TEST_VM(ConcurrentHashTable, concurrent_get_insert_bulk_delete) {
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	953	GI_BD_InserterThread::_shrink = false;
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	954	mt_test_doer<RunnerGI_BD_InserterThread>();
8e4fcfb4cfe4 8195098: Low latency hashtable for read-mostly scenarios rehn parents: diff changeset	955	}
50608 1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	956
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	957	//#############################################################################################
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	958
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	959	class MT_BD_Thread : public JavaTestThread {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	960	TestTable::BulkDeleteTask* _bd;
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	961	public:
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	962	MT_BD_Thread(Semaphore* post, TestTable::BulkDeleteTask* bd)
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	963	: JavaTestThread(post), _bd(bd){}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	964	virtual ~MT_BD_Thread() {}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	965	void main_run() {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	966	MyDel del;
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	967	while(_bd->do_task(this, *this, del));
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	968	}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	969
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	970	bool operator()(uintptr_t* val) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	971	return true;
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	972	}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	973
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	974	struct MyDel {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	975	void operator()(uintptr_t* val) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	976	}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	977	};
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	978	};
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	979
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	980	class Driver_BD_Thread : public JavaTestThread {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	981	public:
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	982	Semaphore _done;
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	983	Driver_BD_Thread(Semaphore* post) : JavaTestThread(post) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	984	};
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	985	virtual ~Driver_BD_Thread(){}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	986
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	987	void main_run() {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	988	Semaphore done(0);
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	989	TestTable* cht = new TestTable(16, 16, 2);
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	990	for (uintptr_t v = 1; v < 99999; v++ ) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	991	TestLookup tl(v);
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	992	EXPECT_TRUE(cht->insert(this, tl, v)) << "Inserting an unique value should work.";
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	993	}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	994	TestTable::BulkDeleteTask bdt(cht, true /* mt */ );
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	995	EXPECT_TRUE(bdt.prepare(this)) << "Uncontended prepare must work.";
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	996
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	997	MT_BD_Thread* tt[4];
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	998	for (int i = 0; i < 4; i++) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	999	tt[i] = new MT_BD_Thread(&done, &bdt);
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1000	tt[i]->doit();
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1001	}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1002
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1003	for (uintptr_t v = 1; v < 99999; v++ ) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1004	TestLookup tl(v);
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1005	cht->get_copy(this, tl);
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1006	}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1007
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1008	for (int i = 0; i < 4; i++) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1009	done.wait();
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1010	}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1011
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1012	bdt.done(this);
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1013
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1014	cht->do_scan(this, *this);
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1015	}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1016
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1017	bool operator()(uintptr_t* val) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1018	EXPECT_TRUE(false) << "No items should left";
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1019	return true;
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1020	}
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1021	};
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1022
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1023	TEST_VM(ConcurrentHashTable, concurrent_mt_bulk_delete) {
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1024	mt_test_doer<Driver_BD_Thread>();
1609a43e77ae 8204857: ConcurrentHashTable: Fix parallel processing rehn parents: 50445 diff changeset	1025	}

author	tschatzl
	Wed, 08 Aug 2018 15:31:07 +0200
changeset 51334	cc2c79d22508
parent 51179	516acf6956a2
child 52877	9e041366c764
permissions	-rw-r--r--