Skip to content

Commit a683036

Browse files
mpirvumpirvu
committed
Reduce the number of VM_isStable messages
The frontend query `isStable(J9Class *fieldClass, int32_t cpIndex)` determines if the field at given J9Class and cpIndex has the @stable annotation. Before this commit, the JITServer implementation had to send a VM_isStable message to the client for every such query. This commit implements caching of the isStable values at JITServer. Caching is done with a hashtable per J9Class, where the key is the cpIndex we are interested in. To further reduce the number of the hashtables that serve as a cache, the `isStable()` will answer `false` for any non-bootstrap class. The reason is that at the moment only bootstrap classs have the @stable annotation. This behavior can be disabled by defining the following environment variable: `TR_DontIgnoreStableAnnotationForUserClasses`. Another optimization regards the implementation of `isArrayWithStableElements(cpIndex, owningMethod, comp)`. In here, we first check to see if we are dealing with an array (which is simpler) and only then call the isStable() query. Signed-off-by: Marius Pirvu <[email protected]>
1 parent cc83b6a commit a683036

14 files changed

+116
-95
lines changed

‎runtime/compiler/control/JITClientCompilationThread.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1275,7 +1275,7 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
12751275
{
12761276
auto recv = client->getRecvData<J9Class *, int>();
12771277
J9Class *fieldClass = std::get<0>(recv);
1278-
int cpIndex = std::get<1>(recv);
1278+
int32_t cpIndex = std::get<1>(recv);
12791279

12801280
bool isStable = fe->isStable(fieldClass, cpIndex);
12811281
client->write(response, isStable);

‎runtime/compiler/control/JITServerHelpers.cpp

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1280,6 +1280,18 @@ JITServerHelpers::getROMClassData(const ClientSessionData::ClassInfo &classInfo,
12801280
}
12811281
}
12821282

1283+
ClientSessionData::ClassInfo &
1284+
JITServerHelpers::getJ9ClassInfo(TR::CompilationInfoPerThread *threadCompInfo, J9Class *clazz)
1285+
{
1286+
// This function assumes that you are inside of _romMapMonitor
1287+
// Do not use it otherwise
1288+
auto &classMap = threadCompInfo->getClientData()->getROMClassMap();
1289+
auto it = classMap.find(clazz);
1290+
TR_ASSERT_FATAL(it != classMap.end(),"compThreadID %d, ClientData %p, clazz %p: ClassInfo is not in the class map %p!!\n",
1291+
threadCompInfo->getCompThreadId(), threadCompInfo->getClientData(), clazz, &classMap);
1292+
return it->second;
1293+
}
1294+
12831295
J9ROMMethod *
12841296
JITServerHelpers::romMethodOfRamMethod(J9Method* method)
12851297
{

‎runtime/compiler/control/JITServerHelpers.hpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -116,6 +116,7 @@ class JITServerHelpers
116116
static bool getAndCacheRAMClassInfo(J9Class *clazz, ClientSessionData *clientSessionData,
117117
JITServer::ServerStream *stream, ClassInfoDataType dataType1, void *data1,
118118
ClassInfoDataType dataType2, void *data2);
119+
static ClientSessionData::ClassInfo &getJ9ClassInfo(TR::CompilationInfoPerThread *threadCompInfo, J9Class *clazz);
119120
static J9ROMMethod *romMethodOfRamMethod(J9Method* method);
120121

121122
static void insertIntoOOSequenceEntryList(ClientSessionData *clientData, TR_MethodToBeCompiled *entry);

‎runtime/compiler/env/VMJ9.cpp

Lines changed: 4 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -1250,9 +1250,8 @@ TR_J9VMBase::getObjectClassInfoFromObjectReferenceLocation(TR::Compilation *comp
12501250
if (knot)
12511251
{
12521252
TR::VMAccessCriticalSection getObjectReferenceLocation(comp);
1253-
uintptr_t objectReference = getStaticReferenceFieldAtAddress
1254-
(objectReferenceLocation);
1255-
ci.clazz = getObjectClass(objectReference);
1253+
uintptr_t objectReference = getStaticReferenceFieldAtAddress(objectReferenceLocation);
1254+
ci.clazz = getObjectClass(objectReference);
12561255
ci.isString = isString(ci.clazz);
12571256
ci.jlClass = getClassClassPointer(ci.clazz);
12581257
ci.isFixedJavaLangClass = (ci.jlClass == ci.clazz);
@@ -3936,7 +3935,7 @@ TR_J9VMBase::canDereferenceAtCompileTimeWithFieldSymbol(TR::Symbol * fieldSymbol
39363935
{
39373936
TR::Compilation *comp = TR::comp();
39383937

3939-
if (isStable(cpIndex, owningMethod, comp))
3938+
if (owningMethod->isStable(cpIndex, comp))
39403939
return true;
39413940

39423941
switch (fieldSymbol->getRecognizedField())
@@ -4013,37 +4012,7 @@ TR_J9VMBase::canDereferenceAtCompileTime(TR::SymbolReference *fieldRef, TR::Comp
40134012
}
40144013

40154014
bool
4016-
TR_J9VMBase::isStable(int cpIndex, TR_ResolvedMethod *owningMethod, TR::Compilation *comp)
4017-
{
4018-
// NOTE: the field must be resolved!
4019-
4020-
if (comp->getOption(TR_DisableStableAnnotations))
4021-
return false;
4022-
4023-
if (cpIndex < 0)
4024-
return false;
4025-
4026-
J9Class *fieldClass = (J9Class*)owningMethod->classOfMethod();
4027-
if (!fieldClass)
4028-
return false;
4029-
4030-
bool isFieldStable = isStable(fieldClass, cpIndex);
4031-
4032-
if (isFieldStable && comp->getOption(TR_TraceOptDetails))
4033-
{
4034-
int classLen;
4035-
const char * className= owningMethod->classNameOfFieldOrStatic(cpIndex, classLen);
4036-
int fieldLen;
4037-
const char * fieldName = owningMethod->fieldNameChars(cpIndex, fieldLen);
4038-
traceMsg(comp, " Found stable field: %.*s.%.*s\n", classLen, className, fieldLen, fieldName);
4039-
}
4040-
4041-
// Not checking for JCL classes since @Stable annotation only visible inside JCL
4042-
return isFieldStable;
4043-
}
4044-
4045-
bool
4046-
TR_J9VMBase::isStable(J9Class *fieldClass, int cpIndex)
4015+
TR_J9VMBase::isStable(J9Class *fieldClass, int32_t cpIndex)
40474016
{
40484017
TR_ASSERT_FATAL(fieldClass, "fieldClass must not be NULL");
40494018
return jitIsFieldStable(vmThread(), fieldClass, cpIndex);

‎runtime/compiler/env/VMJ9.h

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -1081,8 +1081,7 @@ class TR_J9VMBase : public TR_FrontEnd
10811081
* the method accessing the field
10821082
*
10831083
*/
1084-
virtual bool isStable(int cpIndex, TR_ResolvedMethod *owningMethod, TR::Compilation *comp);
1085-
virtual bool isStable(J9Class *fieldClass, int cpIndex);
1084+
virtual bool isStable(J9Class *fieldClass, int32_t cpIndex);
10861085

10871086
/*
10881087
* \brief
@@ -1671,8 +1670,8 @@ class TR_J9SharedCacheVM : public TR_J9VM
16711670
virtual bool supportsJitMethodEntryAlignment() { return false; }
16721671
virtual bool isBenefitInliningCheckIfFinalizeObject() { return true; }
16731672
virtual bool needsContiguousCodeAndDataCacheAllocation() { return true; }
1674-
virtual bool needRelocatableTarget() { return true; }
1675-
virtual bool isStable(int cpIndex, TR_ResolvedMethod *owningMethod, TR::Compilation *comp) { return false; }
1673+
virtual bool needRelocatableTarget() { return true; }
1674+
virtual bool isStable(J9Class *fieldClass, int32_t cpIndex) { return false; }
16761675

16771676
virtual bool isResolvedDirectDispatchGuaranteed(TR::Compilation *comp);
16781677
virtual bool isResolvedVirtualDispatchGuaranteed(TR::Compilation *comp);

‎runtime/compiler/env/VMJ9Server.cpp

Lines changed: 28 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -2518,11 +2518,37 @@ TR_J9ServerVM::isLambdaFormGeneratedMethod(TR_ResolvedMethod *method)
25182518
}
25192519

25202520
bool
2521-
TR_J9ServerVM::isStable(J9Class *fieldClass, int cpIndex)
2521+
TR_J9ServerVM::isStable(J9Class *fieldClass, int32_t cpIndex)
25222522
{
2523+
// See if we cached the presence of the annotation for this class and cpIndex
2524+
{
2525+
OMR::CriticalSection getRemoteROMClass(_compInfoPT->getClientData()->getROMMapMonitor());
2526+
// The fieldClass is guaranteed to be cached at the server because this
2527+
// method is called from a ResolvedMethod
2528+
auto &cache = JITServerHelpers::getJ9ClassInfo(_compInfoPT, fieldClass)._isStableCache;
2529+
auto it = cache.find(cpIndex);
2530+
if (it != cache.end())
2531+
return it->second;
2532+
}
2533+
// At the moment, @Stable annotations are only used in bootstrap classes (this can change though).
2534+
// To limit the number of VM_isStable messages further and to reduce the number of values that
2535+
// are cached in "_isStableCache" cache, we return 'false' when the `fieldClass` is not a bootstrap class.
2536+
static char *dontIgnore = feGetEnv("TR_DontIgnoreStableAnnotationForUserClasses");
2537+
if (!dontIgnore && !isClassLibraryClass((TR_OpaqueClassBlock*)fieldClass))
2538+
return false;
2539+
2540+
// Not cached; send a message and obtain the value
25232541
JITServer::ServerStream *stream = _compInfoPT->getMethodBeingCompiled()->_stream;
25242542
stream->write(JITServer::MessageType::VM_isStable, fieldClass, cpIndex);
2525-
return std::get<0>(stream->read<bool>());
2543+
bool answer = std::get<0>(stream->read<bool>());
2544+
2545+
// Cache the answer
2546+
{
2547+
OMR::CriticalSection getRemoteROMClass(_compInfoPT->getClientData()->getROMMapMonitor());
2548+
auto &cache = JITServerHelpers::getJ9ClassInfo(_compInfoPT, fieldClass)._isStableCache;
2549+
cache.insert({cpIndex, answer});
2550+
}
2551+
return answer;
25262552
}
25272553

25282554
bool

‎runtime/compiler/env/VMJ9Server.hpp

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -172,7 +172,7 @@ class TR_J9ServerVM: public TR_J9VM
172172
virtual uintptr_t getClassFlagsValue(TR_OpaqueClassBlock * clazz) override;
173173
virtual TR_OpaqueMethodBlock *getMethodFromName(const char *className, const char *methodName, const char *signature) override;
174174
virtual TR_OpaqueMethodBlock *getMethodFromClass(TR_OpaqueClassBlock *methodClass, const char *methodName, const char *signature, TR_OpaqueClassBlock *callingClass) override;
175-
virtual bool isStable(J9Class *fieldClass, int cpIndex) override;
175+
virtual bool isStable(J9Class *fieldClass, int32_t cpIndex) override;
176176
virtual bool isForceInline(TR_ResolvedMethod *method) override;
177177
virtual bool isIntrinsicCandidate(TR_ResolvedMethod *method) override;
178178
virtual bool isDontInline(TR_ResolvedMethod *method) override;
@@ -333,7 +333,7 @@ class TR_J9SharedCacheServerVM: public TR_J9ServerVM
333333
virtual bool isResolvedVirtualDispatchGuaranteed(TR::Compilation *comp) override;
334334

335335
virtual bool shouldDelayAotLoad() override { return true; }
336-
virtual bool isStable(int cpIndex, TR_ResolvedMethod *owningMethod, TR::Compilation *comp) override { return false; }
336+
virtual bool isStable(J9Class *fieldClass, int32_t cpIndex) override { return false; }
337337
virtual bool isClassVisible(TR_OpaqueClassBlock *sourceClass, TR_OpaqueClassBlock *destClass) override;
338338
virtual bool stackWalkerMaySkipFrames(TR_OpaqueMethodBlock *method, TR_OpaqueClassBlock *methodClass) override;
339339
virtual bool isMethodTracingEnabled(TR_OpaqueMethodBlock *method) override;

‎runtime/compiler/env/j9method.cpp

Lines changed: 27 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -6449,6 +6449,33 @@ TR_ResolvedJ9Method::getClassFromCP(TR_J9VMBase *fej9, J9ConstantPool *cp, TR::C
64496449
return result;
64506450
}
64516451

6452+
bool
6453+
TR_ResolvedJ9Method::isStable(int32_t cpIndex, TR::Compilation *comp)
6454+
{
6455+
if (comp->getOption(TR_DisableStableAnnotations))
6456+
return false;
6457+
6458+
if (cpIndex < 0)
6459+
return false;
6460+
6461+
J9Class *fieldClass = (J9Class*)classOfMethod();
6462+
if (!fieldClass)
6463+
return false;
6464+
6465+
bool isFieldStable = fej9()->isStable(fieldClass, cpIndex);
6466+
6467+
if (isFieldStable && comp->getOption(TR_TraceOptDetails))
6468+
{
6469+
int classLen;
6470+
const char * className= classNameOfFieldOrStatic(cpIndex, classLen);
6471+
int fieldLen;
6472+
const char * fieldName = fieldNameChars(cpIndex, fieldLen);
6473+
traceMsg(comp, " Found stable field: %.*s.%.*s\n", classLen, className, fieldLen, fieldName);
6474+
}
6475+
6476+
return isFieldStable;
6477+
}
6478+
64526479
TR_OpaqueClassBlock *
64536480
TR_ResolvedJ9Method::getClassFromConstantPool(TR::Compilation * comp, uint32_t cpIndex, bool)
64546481
{

‎runtime/compiler/env/j9method.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -412,6 +412,7 @@ class TR_ResolvedJ9Method : public TR_J9Method, public TR_ResolvedJ9MethodBase
412412
virtual void * callSiteTableEntryAddress(int32_t callSiteIndex);
413413
virtual bool isUnresolvedMethodTypeTableEntry(int32_t cpIndex);
414414
virtual void * methodTypeTableEntryAddress(int32_t cpIndex);
415+
virtual bool isStable(int32_t cpIndex, TR::Compilation *comp) override;
415416
#if defined(J9VM_OPT_METHOD_HANDLE)
416417
virtual bool isUnresolvedVarHandleMethodTypeTableEntry(int32_t cpIndex);
417418
virtual void * varHandleMethodTypeTableEntryAddress(int32_t cpIndex);

‎runtime/compiler/env/j9methodServer.cpp

Lines changed: 14 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -31,17 +31,6 @@
3131
#include "ilgen/J9ByteCodeIterator.hpp"
3232
#include "net/ServerStream.hpp"
3333

34-
ClientSessionData::ClassInfo &
35-
getJ9ClassInfo(TR::CompilationInfoPerThread *threadCompInfo, J9Class *clazz)
36-
{
37-
// This function assumes that you are inside of _romMapMonitor
38-
// Do not use it otherwise
39-
auto &classMap = threadCompInfo->getClientData()->getROMClassMap();
40-
auto it = classMap.find(clazz);
41-
TR_ASSERT_FATAL(it != classMap.end(),"compThreadID %d, ClientData %p, clazz %p: ClassInfo is not in the class map %p!!\n",
42-
threadCompInfo->getCompThreadId(), threadCompInfo->getClientData(), clazz, &classMap);
43-
return it->second;
44-
}
4534

4635
static J9ROMMethod *
4736
romMethodAtClassIndex(J9ROMClass *romClass, uint64_t methodIndex)
@@ -151,7 +140,7 @@ TR_ResolvedJ9JITServerMethod::definingClassFromCPFieldRef(TR::Compilation *comp,
151140
TR::CompilationInfoPerThread *compInfoPT = _fe->_compInfoPT;
152141
{
153142
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
154-
auto &cache = getJ9ClassInfo(compInfoPT, _ramClass)._fieldOrStaticDefiningClassCache;
143+
auto &cache = JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._fieldOrStaticDefiningClassCache;
155144
auto it = cache.find(cpIndex);
156145
if (it != cache.end())
157146
{
@@ -166,7 +155,7 @@ TR_ResolvedJ9JITServerMethod::definingClassFromCPFieldRef(TR::Compilation *comp,
166155
if (resolvedClass)
167156
{
168157
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
169-
auto &cache = getJ9ClassInfo(compInfoPT, _ramClass)._fieldOrStaticDefiningClassCache;
158+
auto &cache = JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._fieldOrStaticDefiningClassCache;
170159
cache.insert({cpIndex, resolvedClass});
171160
}
172161
if (fromResolvedJ9Method != NULL)
@@ -193,7 +182,7 @@ TR_ResolvedJ9JITServerMethod::getClassFromConstantPool(TR::Compilation * comp, u
193182
// This persistent cache must only be checked when doRuntimeResolve is false,
194183
// otherwise a non method handle thunk compilation can return cached value, instead of NULL.
195184
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
196-
auto &constantClassPoolCache = getJ9ClassInfo(compInfoPT, _ramClass)._constantClassPoolCache;
185+
auto &constantClassPoolCache = JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._constantClassPoolCache;
197186
auto it = constantClassPoolCache.find(cpIndex);
198187
if (it != constantClassPoolCache.end())
199188
return it->second;
@@ -204,7 +193,7 @@ TR_ResolvedJ9JITServerMethod::getClassFromConstantPool(TR::Compilation * comp, u
204193
if (resolvedClass)
205194
{
206195
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
207-
auto &constantClassPoolCache = getJ9ClassInfo(compInfoPT, _ramClass)._constantClassPoolCache;
196+
auto &constantClassPoolCache = JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._constantClassPoolCache;
208197
constantClassPoolCache.insert({cpIndex, resolvedClass});
209198
}
210199
return resolvedClass;
@@ -216,7 +205,7 @@ TR_ResolvedJ9JITServerMethod::getDeclaringClassFromFieldOrStatic(TR::Compilation
216205
TR::CompilationInfoPerThread *compInfoPT = _fe->_compInfoPT;
217206
{
218207
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
219-
auto &cache = getJ9ClassInfo(compInfoPT, _ramClass)._fieldOrStaticDeclaringClassCache;
208+
auto &cache = JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._fieldOrStaticDeclaringClassCache;
220209
auto it = cache.find(cpIndex);
221210
if (it != cache.end())
222211
return it->second;
@@ -226,7 +215,7 @@ TR_ResolvedJ9JITServerMethod::getDeclaringClassFromFieldOrStatic(TR::Compilation
226215
if (declaringClass)
227216
{
228217
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
229-
auto &cache = getJ9ClassInfo(compInfoPT, _ramClass)._fieldOrStaticDeclaringClassCache;
218+
auto &cache = JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._fieldOrStaticDeclaringClassCache;
230219
cache.insert({cpIndex, declaringClass});
231220
}
232221
return declaringClass;
@@ -242,7 +231,7 @@ TR_ResolvedJ9JITServerMethod::classOfStatic(I_32 cpIndex, bool returnClassForAOT
242231
auto compInfoPT = static_cast<TR::CompilationInfoPerThreadRemote *>(_fe->_compInfoPT);
243232
{
244233
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
245-
auto &classOfStaticCache = getJ9ClassInfo(compInfoPT, _ramClass)._classOfStaticCache;
234+
auto &classOfStaticCache = JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._classOfStaticCache;
246235
auto it = classOfStaticCache.find(cpIndex);
247236
if (it != classOfStaticCache.end())
248237
return it->second;
@@ -260,7 +249,7 @@ TR_ResolvedJ9JITServerMethod::classOfStatic(I_32 cpIndex, bool returnClassForAOT
260249
// if client returned NULL, don't cache, because class might not be fully initialized,
261250
// so the result may change in the future
262251
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
263-
auto &classOfStaticCache = getJ9ClassInfo(compInfoPT, _ramClass)._classOfStaticCache;
252+
auto &classOfStaticCache = JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._classOfStaticCache;
264253
classOfStaticCache.insert({cpIndex, classOfStatic});
265254
}
266255
else
@@ -534,8 +523,8 @@ TR_ResolvedJ9JITServerMethod::getAttributesCache(bool isStatic, bool unresolvedI
534523
// Return a persistent attributes cache for regular JIT compilations
535524
TR::CompilationInfoPerThread *compInfoPT = _fe->_compInfoPT;
536525
auto &attributesCache = isStatic ?
537-
getJ9ClassInfo(compInfoPT, _ramClass)._staticAttributesCache :
538-
getJ9ClassInfo(compInfoPT, _ramClass)._fieldAttributesCache;
526+
JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._staticAttributesCache :
527+
JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._fieldAttributesCache;
539528
return attributesCache;
540529
}
541530

@@ -2738,8 +2727,8 @@ TR_ResolvedRelocatableJ9JITServerMethod::getAttributesCache(bool isStatic, bool
27382727
// Return persistent attributes cache for AOT compilations
27392728
TR::CompilationInfoPerThread *compInfoPT = _fe->_compInfoPT;
27402729
auto &attributesCache = isStatic ?
2741-
getJ9ClassInfo(compInfoPT, _ramClass)._staticAttributesCacheAOT :
2742-
getJ9ClassInfo(compInfoPT, _ramClass)._fieldAttributesCacheAOT;
2730+
JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._staticAttributesCacheAOT :
2731+
JITServerHelpers::getJ9ClassInfo(compInfoPT, _ramClass)._fieldAttributesCacheAOT;
27432732
return attributesCache;
27442733
}
27452734

@@ -2775,7 +2764,7 @@ TR_J9ServerMethod::TR_J9ServerMethod(TR_FrontEnd * fe, TR_Memory * trMemory, J9C
27752764
{
27762765
// look up parameters for construction of this method in a cache first
27772766
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
2778-
auto &cache = getJ9ClassInfo(compInfoPT, aClazz)._J9MethodNameCache;
2767+
auto &cache = JITServerHelpers::getJ9ClassInfo(compInfoPT, aClazz)._J9MethodNameCache;
27792768
// search the cache for existing method parameters
27802769
auto it = cache.find(cpIndex);
27812770
if (it != cache.end())
@@ -2799,7 +2788,7 @@ TR_J9ServerMethod::TR_J9ServerMethod(TR_FrontEnd * fe, TR_Memory * trMemory, J9C
27992788
methodSignatureStr = std::get<2>(recv);
28002789

28012790
OMR::CriticalSection getRemoteROMClass(compInfoPT->getClientData()->getROMMapMonitor());
2802-
auto &cache = getJ9ClassInfo(compInfoPT, aClazz)._J9MethodNameCache;
2791+
auto &cache = JITServerHelpers::getJ9ClassInfo(compInfoPT, aClazz)._J9MethodNameCache;
28032792
cache.insert({cpIndex, {classNameStr, methodNameStr, methodSignatureStr}});
28042793
}
28052794

‎runtime/compiler/net/CommunicationStream.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -129,7 +129,7 @@ class CommunicationStream
129129
// likely to lose an increment when merging/rebasing/etc.
130130
//
131131
static const uint8_t MAJOR_NUMBER = 1;
132-
static const uint16_t MINOR_NUMBER = 77; // ID: J440z7/ZN5+KF233VhGB
132+
static const uint16_t MINOR_NUMBER = 78; // ID: J440z7/ZN5+KF233VhGB
133133
static const uint8_t PATCH_NUMBER = 0;
134134
static uint32_t CONFIGURATION_FLAGS;
135135

0 commit comments

Comments
 (0)