ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/jsr166/jsr166/src/test/loops/StringMapLoops.java

Comparing jsr166/src/test/loops/StringMapLoops.java (file contents):
Revision 1.4 by jsr166, Thu Oct 29 23:09:08 2009 UTC vs.
Revision 1.15 by jsr166, Sun Oct 23 03:03:24 2016 UTC

#	Line 1 | Line 1
1		/*
2		* Written by Doug Lea with assistance from members of JCP JSR-166
3		* Expert Group and released to the public domain, as explained at
4	<	* http://creativecommons.org/licenses/publicdomain
4	>	* http://creativecommons.org/publicdomain/zero/1.0/
5		*/
6
7	+	import java.io.*;
8	+	import java.math.*;
9		import java.util.*;
10		import java.util.concurrent.*;
11
12		public class StringMapLoops {
13	<	static int nkeys       = 75000;
13	>	static int nkeys       = 147456;
14		static int pinsert     = 60;
15	<	static int premove     =  2;
15	>	static int premove     =  5;
16		static int maxThreads  = 100;
17		static int nops        = 8000000;
18		static int removesPerMaxRandom;
#	Line 20 | Line 22 | public class StringMapLoops {
22
23		public static void main(String[] args) throws Exception {
24
25	<	Class mapClass = null;
25	>	Class<?> mapClass = null;
26		if (args.length > 0) {
27		try {
28		mapClass = Class.forName(args[0]);
29	<	} catch(ClassNotFoundException e) {
29	>	} catch (ClassNotFoundException e) {
30		throw new RuntimeException("Class " + args[0] + " not found.");
31		}
32		}
#	Line 58 | Line 60 | public class StringMapLoops {
60		System.out.print(" ops: " + nops);
61		System.out.println();
62
63	<	String[] key = makeKeys(nkeys);
63	>	String[] key = new String[nkeys];
64	>	initStringKeys(key, nkeys);
65	>	//        String[] key = makeKeys(nkeys);
66
63	–	int k = 1;
67		int warmups = 2;
68	<	for (int i = 1; i <= maxThreads;) {
68	>	for (int k = 1, i = 1; i <= maxThreads;) {
69		Thread.sleep(100);
70		test(i, nkeys, key, mapClass);
71		shuffleKeys(key);
#	Line 87 | Line 90 | public class StringMapLoops {
90		pool.shutdown();
91		}
92
90	–	static String[] makeKeys(int n) {
91	–	LoopHelpers.SimpleRandom rng = new LoopHelpers.SimpleRandom();
92	–	String[] key = new String[n];
93	–	for (int i = 0; i < key.length; ++i) {
94	–	int k = 0;
95	–	int len = 1 + (rng.next() & 0xf);
96	–	char[] c = new char[len * 4];
97	–	for (int j = 0; j < len; ++j) {
98	–	int r = rng.next();
99	–	c[k++] = (char)(' ' + (r & 0x7f));
100	–	r >>>= 8;
101	–	c[k++] = (char)(' ' + (r & 0x7f));
102	–	r >>>= 8;
103	–	c[k++] = (char)(' ' + (r & 0x7f));
104	–	r >>>= 8;
105	–	c[k++] = (char)(' ' + (r & 0x7f));
106	–	}
107	–	key[i] = new String(c);
108	–	}
109	–	return key;
110	–	}
111	–
93		static void shuffleKeys(String[] key) {
94		Random rng = new Random();
95		for (int i = key.length; i > 1; --i) {
#	Line 119 | Line 100 | public class StringMapLoops {
100		}
101		}
102
103	<	static void test(int i, int nkeys, String[] key, Class mapClass) throws Exception {
103	>	static void test(int i, int nkeys, String[] key, Class<?> mapClass) throws Exception {
104		System.out.print("Threads: " + i + "\t:");
105	<	Map<String, String> map = (Map<String,String>)mapClass.newInstance();
105	>	Map<String, String> map =
106	>	(Map<String,String>) mapClass.getConstructor().newInstance();
107		// Uncomment to start with a non-empty table
108		//        for (int j = 0; j < nkeys; j += 4) // start 1/4 occupied
109		//            map.put(key[j], key[j]);
#	Line 133 | Line 115 | public class StringMapLoops {
115		barrier.await();
116		barrier.await();
117		long time = timer.getTime();
118	<	long tpo = time / (i * (long)nops);
118	>	long tpo = time / (i * (long) nops);
119		System.out.print(LoopHelpers.rightJustify(tpo) + " ns per op");
120	<	double secs = (double)(time) / 1000000000.0;
120	>	double secs = (double) time / 1000000000.0;
121		System.out.println("\t " + secs + "s run time");
122		map.clear();
123		}
#	Line 158 | Line 140 | public class StringMapLoops {
140		}
141
142		int step() {
143	<	// random-walk around key positions,  bunching accesses
143	>	// random-walk around key positions, bunching accesses
144		int r = rng.next();
145		position += (r & 7) - 3;
146		while (position >= key.length) position -= key.length;
#	Line 177 | Line 159 | public class StringMapLoops {
159		}
160		else if (r < insertsPerMaxRandom) {
161		++position;
162	+	//                map.putIfAbsent(k, k);
163		map.put(k, k);
164		return 2;
165		}
#	Line 198 | Line 181 | public class StringMapLoops {
181		}
182		}
183		}
184	+
185	+	static final String wordFile = "testwords.txt";
186	+
187	+	// Read in String keys from file if possible
188	+	static void initStringKeys(String[] keys, int n) throws Exception {
189	+	FileInputStream fr = null;
190	+	try {
191	+	fr = new FileInputStream(wordFile);
192	+	} catch (IOException ex) {
193	+	System.out.println("No word file. Using String.valueOf(i)");
194	+	for (int i = 0; i < n; i++)
195	+	keys[i] = String.valueOf(i);
196	+	return;
197	+	}
198	+
199	+	BufferedInputStream in = new BufferedInputStream(fr);
200	+	int k = 0;
201	+	outer:while (k < n) {
202	+	StringBuffer sb = new StringBuffer();
203	+	for (;;) {
204	+	int c = in.read();
205	+	if (c < 0)
206	+	break outer;
207	+	char ch = (char) c;
208	+	if (ch == '\n') {
209	+	keys[k++] = sb.toString();
210	+	break;
211	+	}
212	+	if (!Character.isWhitespace(ch))
213	+	sb.append(ch);
214	+	}
215	+	}
216	+	in.close();
217	+
218	+	// fill up remaining keys with path-like compounds of previous pairs
219	+	int j = 0;
220	+	while (k < n)
221	+	keys[k++] = keys[j++] + "/" + keys[j];
222	+	}
223		}

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines