1 /*
2 * Copyright (c) 2016, 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 #include "precompiled.hpp"
25 #include "runtime/interfaceSupport.inline.hpp"
26 #include "classfile/symbolTable.hpp"
27 #include "threadHelper.inline.hpp"
28 #include "unittest.hpp"
29
TEST_VM(SymbolTable,temp_new_symbol)30 TEST_VM(SymbolTable, temp_new_symbol) {
31 // Assert messages assume these symbols are unique, and the refcounts start at
32 // one, but code does not rely on this.
33 JavaThread* THREAD = JavaThread::current();
34 // the thread should be in vm to use locks
35 ThreadInVMfromNative ThreadInVMfromNative(THREAD);
36
37 Symbol* abc = SymbolTable::new_symbol("abc");
38 int abccount = abc->refcount();
39 TempNewSymbol ss = abc;
40 ASSERT_EQ(ss->refcount(), abccount) << "only one abc";
41 ASSERT_EQ(ss->refcount(), abc->refcount()) << "should match TempNewSymbol";
42
43 Symbol* efg = SymbolTable::new_symbol("efg");
44 Symbol* hij = SymbolTable::new_symbol("hij");
45 int efgcount = efg->refcount();
46 int hijcount = hij->refcount();
47
48 TempNewSymbol s1 = efg;
49 TempNewSymbol s2 = hij;
50 ASSERT_EQ(s1->refcount(), efgcount) << "one efg";
51 ASSERT_EQ(s2->refcount(), hijcount) << "one hij";
52
53 // Assignment operator
54 s1 = s2;
55 ASSERT_EQ(hij->refcount(), hijcount + 1) << "should be two hij";
56 ASSERT_EQ(efg->refcount(), efgcount - 1) << "should be no efg";
57
58 s1 = ss; // s1 is abc
59 ASSERT_EQ(s1->refcount(), abccount + 1) << "should be two abc (s1 and ss)";
60 ASSERT_EQ(hij->refcount(), hijcount) << "should only have one hij now (s2)";
61
62 s1 = s1; // self assignment
63 ASSERT_EQ(s1->refcount(), abccount + 1) << "should still be two abc (s1 and ss)";
64
65 TempNewSymbol s3;
66 Symbol* klm = SymbolTable::new_symbol("klm");
67 int klmcount = klm->refcount();
68 s3 = klm; // assignment
69 ASSERT_EQ(s3->refcount(), klmcount) << "only one klm now";
70
71 Symbol* xyz = SymbolTable::new_symbol("xyz");
72 int xyzcount = xyz->refcount();
73 { // inner scope
74 TempNewSymbol s_inner = xyz;
75 }
76 ASSERT_EQ(xyz->refcount(), xyzcount - 1)
77 << "Should have been decremented by dtor in inner scope";
78
79 // Test overflowing refcount making symbol permanent
80 Symbol* bigsym = SymbolTable::new_symbol("bigsym");
81 for (int i = 0; i < PERM_REFCOUNT + 100; i++) {
82 bigsym->increment_refcount();
83 }
84 ASSERT_EQ(bigsym->refcount(), PERM_REFCOUNT) << "should not have overflowed";
85
86 // Test that PERM_REFCOUNT is sticky
87 for (int i = 0; i < 10; i++) {
88 bigsym->decrement_refcount();
89 }
90 ASSERT_EQ(bigsym->refcount(), PERM_REFCOUNT) << "should be sticky";
91 }
92
93 // TODO: Make two threads one decrementing the refcount and the other trying to increment.
94 // try_increment_refcount should return false
95
96 #define SYM_NAME_LENGTH 30
97 static char symbol_name[SYM_NAME_LENGTH];
98
99 class SymbolThread : public JavaTestThread {
100 public:
SymbolThread(Semaphore * post)101 SymbolThread(Semaphore* post) : JavaTestThread(post) {}
~SymbolThread()102 virtual ~SymbolThread() {}
main_run()103 void main_run() {
104 for (int i = 0; i < 1000; i++) {
105 TempNewSymbol sym = SymbolTable::new_symbol(symbol_name);
106 // Create and destroy new symbol
107 EXPECT_TRUE(sym->refcount() != 0) << "Symbol refcount unexpectedly zeroed";
108 }
109 }
110 };
111
112 #define SYM_TEST_THREAD_COUNT 5
113
114 class DriverSymbolThread : public JavaTestThread {
115 public:
116 Semaphore _done;
DriverSymbolThread(Semaphore * post)117 DriverSymbolThread(Semaphore* post) : JavaTestThread(post) { };
~DriverSymbolThread()118 virtual ~DriverSymbolThread(){}
119
main_run()120 void main_run() {
121 Semaphore done(0);
122
123 // Find a symbol where there will probably be only one instance.
124 for (int i = 0; i < 100; i++) {
125 os::snprintf(symbol_name, SYM_NAME_LENGTH, "some_symbol%d", i);
126 TempNewSymbol ts = SymbolTable::new_symbol(symbol_name);
127 if (ts->refcount() == 1) {
128 EXPECT_TRUE(ts->refcount() == 1) << "Symbol is just created";
129 break; // found a unique symbol
130 }
131 }
132
133 SymbolThread* st[SYM_TEST_THREAD_COUNT];
134 for (int i = 0; i < SYM_TEST_THREAD_COUNT; i++) {
135 st[i] = new SymbolThread(&done);
136 st[i]->doit();
137 }
138
139 for (int i = 0; i < SYM_TEST_THREAD_COUNT; i++) {
140 done.wait();
141 }
142 }
143 };
144
TEST_VM(SymbolTable,test_symbol_refcount_parallel)145 TEST_VM(SymbolTable, test_symbol_refcount_parallel) {
146 mt_test_doer<DriverSymbolThread>();
147 }
148