~slub.team/goobi-indexserver/3.x

ConcurrentLRUCache cache = new ConcurrentLRUCache(upperWaterMark, lowerWaterMark, (upperWaterMark+lowerWaterMark)/2, upperWaterMark, false, false, null);

119

boolean getSize=false;

120

int minSize=0,maxSize=0;

121

for (int i=0; i<iter; i++) {

122

cache.put(r.nextInt(maxKey),"TheValue");

123

int sz = cache.size();

124

if (!getSize && sz >= cacheSize) {

125

getSize = true;

126

minSize = sz;

127

} else {

128

if (sz < minSize) minSize=sz;

129

else if (sz > maxSize) maxSize=sz;

130

}

131

}

132

cache.destroy();

133

134

long end = System.currentTimeMillis();

135

System.out.println("time=" + (end-start) + ", minSize="+minSize+",maxSize="+maxSize);

136

}

137

138

/***

139

public void testPerf() {

140

doPerfTest(1000000, 100000, 200000); // big cache, warmup

141

doPerfTest(2000000, 100000, 200000); // big cache

142

doPerfTest(2000000, 100000, 120000); // smaller key space increases distance between oldest, newest and makes the first passes less effective.

143

doPerfTest(6000000, 1000, 2000); // small cache, smaller hit rate

144

doPerfTest(6000000, 1000, 1200); // small cache, bigger hit rate

145

}

146

***/

147

148

// returns number of puts

149

int useCache(SolrCache sc, int numGets, int maxKey, int seed) {

150

int ret = 0;

151

Random r = new Random(seed);

152

153

// use like a cache... gets and a put if not found

154

for (int i=0; i<numGets; i++) {

155

Integer k = r.nextInt(maxKey);

156

Integer v = (Integer)sc.get(k);

157

if (v == null) {

158

sc.put(k, k);

159

ret++;

160

}

161

}

162

163

return ret;

164

}

165

166

void fillCache(SolrCache sc, int cacheSize, int maxKey) {

167

for (int i=0; i<cacheSize; i++) {

168

Integer kv = random.nextInt(maxKey);

169

sc.put(kv,kv);

170

}

171

}

172

173

174

void cachePerfTest(final SolrCache sc, final int nThreads, final int numGets, int cacheSize, final int maxKey) {

175

Map l = new HashMap();

176

l.put("size", ""+cacheSize);

177

l.put("initialSize", ""+cacheSize);

178

179

Object o = sc.init(l, null, null);

180

sc.setState(SolrCache.State.LIVE);

181

182

fillCache(sc, cacheSize, maxKey);

183

184

long start = System.currentTimeMillis();

185

186

Thread[] threads = new Thread[nThreads];

187

final AtomicInteger puts = new AtomicInteger(0);

188

for (int i=0; i<threads.length; i++) {

189

final int seed=random.nextInt();

190

threads[i] = new Thread() {

191

@Override

192

public void run() {

193

int ret = useCache(sc, numGets/nThreads, maxKey, seed);

194

puts.addAndGet(ret);

195

}

196

};

197

}

198

199

for (Thread thread : threads) {

200

try {

201

thread.start();

202

} catch (Exception e) {

203

e.printStackTrace();

204

}

205

}

206

207

for (Thread thread : threads) {

208

try {

209

thread.join();

210

} catch (Exception e) {

211

e.printStackTrace();

212

}

213

}

214

215

long end = System.currentTimeMillis();

216

System.out.println("time=" + (end-start) + " impl=" +sc.getClass().getSimpleName()

217

+" nThreads= " + nThreads + " size="+cacheSize+" maxKey="+maxKey+" gets="+numGets

218

+" hitRatio="+(1-(((double)puts.get())/numGets)));

219

}

220

221

void perfTestBoth(int nThreads, int numGets, int cacheSize, int maxKey) {

222

cachePerfTest(new LRUCache(), nThreads, numGets, cacheSize, maxKey);

223

cachePerfTest(new FastLRUCache(), nThreads, numGets, cacheSize, maxKey);

224

}

225

226

/***

227

public void testCachePerf() {

228

// warmup

229

perfTestBoth(2, 100000, 100000, 120000);

230

perfTestBoth(1, 2000000, 100000, 100000); // big cache, 100% hit ratio

231

perfTestBoth(2, 2000000, 100000, 100000); // big cache, 100% hit ratio

232

perfTestBoth(1, 2000000, 100000, 120000); // big cache, bigger hit ratio

233

perfTestBoth(2, 2000000, 100000, 120000); // big cache, bigger hit ratio

234

perfTestBoth(1, 2000000, 100000, 200000); // big cache, ~50% hit ratio

235

perfTestBoth(2, 2000000, 100000, 200000); // big cache, ~50% hit ratio

236

perfTestBoth(1, 2000000, 100000, 1000000); // big cache, ~10% hit ratio

237

perfTestBoth(2, 2000000, 100000, 1000000); // big cache, ~10% hit ratio

238

239

perfTestBoth(1, 2000000, 1000, 1000); // small cache, ~100% hit ratio

240

perfTestBoth(2, 2000000, 1000, 1000); // small cache, ~100% hit ratio

241

perfTestBoth(1, 2000000, 1000, 1200); // small cache, bigger hit ratio

242

perfTestBoth(2, 2000000, 1000, 1200); // small cache, bigger hit ratio

243

perfTestBoth(1, 2000000, 1000, 2000); // small cache, ~50% hit ratio

244

perfTestBoth(2, 2000000, 1000, 2000); // small cache, ~50% hit ratio

245

perfTestBoth(1, 2000000, 1000, 10000); // small cache, ~10% hit ratio

246

perfTestBoth(2, 2000000, 1000, 10000); // small cache, ~10% hit ratio

247

}

248

***/

249

250

251

}

Older »