Merge pull request #22071 from mpirvu/dltjitserver

Eliminate VM_compiledAsDLTBefore message for JITServer

Author: dsouzai

runtime/compiler/control/CompilationRuntime.hpp

@@ -40,6 +40,7 @@
 #include "control/rossa.h"
 #include "runtime/RelocationRuntime.hpp"
 #if defined(J9VM_OPT_JITSERVER)
+#include <vector>
 #include "control/JITServerHelpers.hpp"
 #include "env/PersistentCollections.hpp"
 #include "net/ServerStream.hpp"
@@ -788,6 +789,9 @@ class CompilationInfo
    void  cleanDLTRecordOnUnload();
    DLTTracking *getDLT_HT() const { return _dltHT; }
    void setDLT_HT(DLTTracking *dltHT) { _dltHT = dltHT; }
+#if defined(J9VM_OPT_JITSERVER)
+   std::vector<J9Method*> collectDLTedMethods();
+#endif /* defined(J9VM_OPT_JITSERVER) */
 #else
    DLTTracking *getDLT_HT() const { return NULL; }
 #endif // J9VM_JIT_DYNAMIC_LOOP_TRANSFER
@@ -1229,6 +1233,7 @@ class CompilationInfo
    TR::Monitor *_dltMonitor;
    struct DLT_record     *_freeDLTRecord;
    struct DLT_record     *_dltHash[DLT_HASHSIZE];
+   int32_t _numDLTRecords;
 #endif
    DLTTracking           *_dltHT;
 

runtime/compiler/control/CompilationThread.cpp

@@ -3100,6 +3100,7 @@ TR::CompilationInfo::startCompilationThread(int32_t priority, int32_t threadId,
    }
 
 #if defined(J9VM_JIT_DYNAMIC_LOOP_TRANSFER)
+
 void *TR::CompilationInfo::searchForDLTRecord(J9Method *method, int32_t bcIndex)
    {
    int32_t hashVal = (intptr_t)method * bcIndex % DLT_HASHSIZE;
@@ -3187,6 +3188,7 @@ void TR::CompilationInfo::insertDLTRecord(J9Method *method, int32_t bcIndex, voi
    // Doing this means we don't need locking when reading the _dltHash linked lists
    FLUSH_MEMORY(TR::Compiler->target.isSMP());
    _dltHash[hashVal] = myRecord;
+   _numDLTRecords++;
    }
    }
 
@@ -3213,14 +3215,37 @@ void TR::CompilationInfo::cleanDLTRecordOnUnload()
             // FIXME: free the codeCache
             curr->_next = _freeDLTRecord;
             _freeDLTRecord = curr;
+            _numDLTRecords--;
             }
          else
             prev = curr;
          curr = next;
          }
       }
    }
-#endif
+
+#if defined(J9VM_OPT_JITSERVER)
+// Method executed by the client to gather all methods that have been DLTed before.
+// The result is put into a vector of J9Method* which will be sent to the server.
+// This operation is only needed when the client connects to a brand new server.
+std::vector<J9Method*> TR::CompilationInfo::collectDLTedMethods()
+   {
+   std::vector<J9Method*> dltedMethods;
+   dltedMethods.reserve(_numDLTRecords); // overestimate
+   OMR::CriticalSection cs(_dltMonitor);
+   for (int32_t i = 0; i < DLT_HASHSIZE; i++)
+      {
+      struct DLT_record *dltPtr = _dltHash[i];
+      while (dltPtr)
+         {
+         dltedMethods.push_back(dltPtr->_method);
+         dltPtr = dltPtr->_next;
+         }
+      }
+   return dltedMethods;
+   }
+#endif /* defined(J9VM_OPT_JITSERVER) */
+#endif /* defined(J9VM_JIT_DYNAMIC_LOOP_TRANSFER) */
 
 #ifdef INVOCATION_STATS
 extern "C" J9Method * getNewInstancePrototype(J9VMThread * context);
@@ -10287,6 +10312,11 @@ TR::CompilationInfo::compilationEnd(J9VMThread * vmThread, TR::IlGeneratorMethod
          if (startPC) // compilation succeeded
             {
             outOfProcessCompilationEnd(entry, comp);
+            // Update the set of DLT compilations maintained by the server
+            ClientSessionData *clientSession = comp->getClientData();
+            J9Method *method = details.getMethod();
+            OMR::CriticalSection cs(clientSession->getDLTSetMonitor());
+            clientSession->getDLTedMethodSet().insert(method);
             }
          else if (entry) // failure
             {

runtime/compiler/control/JITClientCompilationThread.cpp

@@ -263,6 +263,13 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
             compInfo->getclassesCachedAtServer().clear();
             }
 
+         // Add the list of methods that were DLTed
+#if defined(J9VM_JIT_DYNAMIC_LOOP_TRANSFER)
+         std::vector<J9Method*> dltedMethods = compInfo->collectDLTedMethods();
+#else
+         std::vector<J9Method*> dltedMethods; // empty
+#endif /* defined(J9VM_JIT_DYNAMIC_LOOP_TRANSFER) */
+
          // This is a connection to a new server after a previous disconnection
          if (hasEverConnectedToServer && (previousUID != serverUID))
             {
@@ -276,7 +283,7 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
             compInfo->getPersistentInfo()->setDoNotRequestJITServerAOTCacheStore(false);
             }
 
-         client->write(response, ranges, unloadedClasses->getMaxRanges(), serializedCHTable);
+         client->write(response, ranges, unloadedClasses->getMaxRanges(), serializedCHTable, dltedMethods);
 
          if ((previousUID != serverUID) && TR::Options::getVerboseOption(TR_VerboseJITServerConns))
             {
@@ -353,12 +360,6 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
          client->write(response, declaringClass1, declaringClass2, f1, f2);
          };
          break;
-      case MessageType::VM_compiledAsDLTBefore:
-         {
-         auto clazz = std::get<0>(client->getRecvData<TR_ResolvedMethod *>());
-         client->write(response, fe->compiledAsDLTBefore(clazz));
-         }
-         break;
       case MessageType::VM_classHasBeenExtended:
          {
          auto clazz = std::get<0>(client->getRecvData<TR_OpaqueClassBlock *>());

runtime/compiler/control/JITServerCompilationThread.cpp

@@ -265,13 +265,13 @@ outOfProcessCompilationEnd(TR_MethodToBeCompiled *entry, TR::Compilation *comp)
       if (TR::Options::getVerboseOption(TR_VerboseJITServer))
          {
          TR_VerboseLog::writeLineLocked(TR_Vlog_JITServer, "compThreadID=%d has successfully compiled %s memoryState=%d",
-            compInfoPT->getCompThreadId(), compInfoPT->getCompilation()->signature(), memoryState);
+            compInfoPT->getCompThreadId(), comp->signature(), memoryState);
          }
       }
    compInfoPT->clearPerCompilationCaches();
 
    Trc_JITServerCompileEnd(compInfoPT->getCompilationThread(), compInfoPT->getCompThreadId(),
-         compInfoPT->getCompilation()->signature(), compInfoPT->getCompilation()->getHotnessName());
+      comp->signature(), comp->getHotnessName());
 
    // Check whether we need to save a copy of the AOTcache in a file
    if (compInfoPT->getCompilationInfo()->getPersistentInfo()->getJITServerUseAOTCachePersistence())
@@ -750,11 +750,12 @@ TR::CompilationInfoPerThreadRemote::processCompilationRequest(CompilationRequest
                getCompThreadId(), (unsigned long long)clientId);
 
          stream->write(JITServer::MessageType::getUnloadedClassRangesAndCHTable, compInfo->getPersistentInfo()->getServerUID());
-         auto response = stream->read<std::vector<TR_AddressRange>, int32_t, std::string>();
+         auto response = stream->read<std::vector<TR_AddressRange>, int32_t, std::string, std::vector<J9Method*>>();
          // TODO: we could send JVM info that is global and does not change together with CHTable
          auto &unloadedClassRanges = std::get<0>(response);
          auto maxRanges = std::get<1>(response);
          std::string &serializedCHTable = std::get<2>(response);
+         std::vector<J9Method*> &dltedMethods = std::get<3>(response);
 
          clientSession->initializeUnloadedClassAddrRanges(unloadedClassRanges, maxRanges);
          if (!unloadedClasses.empty())
@@ -771,6 +772,13 @@ TR::CompilationInfoPerThreadRemote::processCompilationRequest(CompilationRequest
             TR_VerboseLog::writeLineLocked(TR_Vlog_JITServer, "compThreadID=%d will initialize CHTable for clientUID %llu size=%zu",
                getCompThreadId(), (unsigned long long)clientId, serializedCHTable.size());
          chTable->initializeCHTable(_vm, serializedCHTable);
+#if defined(J9VM_JIT_DYNAMIC_LOOP_TRANSFER)
+         {
+         OMR::CriticalSection cs(clientSession->getDLTSetMonitor());
+         clientSession->getDLTedMethodSet().insert(dltedMethods.begin(), dltedMethods.end());
+         }
+#endif /* defined(J9VM_JIT_DYNAMIC_LOOP_TRANSFER) */
+
          clientSession->setCachesAreCleared(false);
          initializedCHTable = true;
          }

runtime/compiler/env/VMJ9Server.cpp

@@ -663,11 +663,16 @@ TR_J9ServerVM::isGetImplAndRefersToInliningSupported()
 bool
 TR_J9ServerVM::compiledAsDLTBefore(TR_ResolvedMethod *method)
    {
+   // The server keeps track of DLT compilations that have been performed,
+   // so no messages need to be sent to the client
 #if defined(J9VM_JIT_DYNAMIC_LOOP_TRANSFER)
-   JITServer::ServerStream *stream = _compInfoPT->getMethodBeingCompiled()->_stream;
-   auto mirror = static_cast<TR_ResolvedJ9JITServerMethod *>(method)->getRemoteMirror();
-   stream->write(JITServer::MessageType::VM_compiledAsDLTBefore, static_cast<TR_ResolvedMethod *>(mirror));
-   return std::get<0>(stream->read<bool>());
+   TR_ResolvedJ9JITServerMethod *serverMethod = static_cast<TR_ResolvedJ9JITServerMethod*>(method);
+   J9Method *j9method = serverMethod->ramMethod();
+
+   ClientSessionData *clientData = _compInfoPT->getClientData();
+   auto &dltedMethodSet = clientData->getDLTedMethodSet();
+   OMR::CriticalSection cs(clientData->getDLTSetMonitor());
+   return dltedMethodSet.find(j9method) != dltedMethodSet.end();
 #else
    return 0;
 #endif

runtime/compiler/net/CommunicationStream.hpp

@@ -129,7 +129,7 @@ class CommunicationStream
    // likely to lose an increment when merging/rebasing/etc.
    //
    static const uint8_t MAJOR_NUMBER = 1;
-   static const uint16_t MINOR_NUMBER = 83; // ID: yInQ3zszluYaDVc6hSwi
+   static const uint16_t MINOR_NUMBER = 84; // ID: gIq88QhwCmuOoBAlidaE
    static const uint8_t PATCH_NUMBER = 0;
    static uint32_t CONFIGURATION_FLAGS;
 

runtime/compiler/net/MessageTypes.cpp

@@ -106,7 +106,6 @@ const char *messageNames[] =
    "VM_getClassFromSignature",
    "VM_jitFieldsOrStaticsAreSame",
    "VM_classHasBeenExtended",
-   "VM_compiledAsDLTBefore",
    "VM_isThunkArchetype",
    "VM_printTruncatedSignature",
    "VM_getStaticHookAddress",

runtime/compiler/net/MessageTypes.hpp

@@ -115,7 +115,6 @@ enum MessageType : uint16_t
    VM_getClassFromSignature,
    VM_jitFieldsOrStaticsAreSame,
    VM_classHasBeenExtended,
-   VM_compiledAsDLTBefore,
    VM_isThunkArchetype,
    VM_printTruncatedSignature,
    VM_getStaticHookAddress,

runtime/compiler/runtime/JITClientSession.cpp

@@ -47,6 +47,7 @@ ClientSessionData::ClientSessionData(uint64_t clientUID, uint32_t seqNo, TR_Pers
    _romClassMap(decltype(_romClassMap)::allocator_type(persistentMemory->_persistentAllocator.get())),
    _J9MethodMap(decltype(_J9MethodMap)::allocator_type(persistentMemory->_persistentAllocator.get())),
    _classBySignatureMap(decltype(_classBySignatureMap)::allocator_type(persistentMemory->_persistentAllocator.get())),
+   _DLTedMethodSet(decltype(_DLTedMethodSet)::allocator_type(persistentMemory->_persistentAllocator.get())),
    _classChainDataMap(decltype(_classChainDataMap)::allocator_type(persistentMemory->_persistentAllocator.get())),
    _constantPoolToClassMap(decltype(_constantPoolToClassMap)::allocator_type(persistentMemory->_persistentAllocator.get())),
    _unloadedClassAddresses(NULL),
@@ -72,6 +73,7 @@ ClientSessionData::ClientSessionData(uint64_t clientUID, uint32_t seqNo, TR_Pers
    _numActiveThreads = 0;
    _romMapMonitor = TR::Monitor::create("JIT-JITServerROMMapMonitor");
    _classMapMonitor = TR::Monitor::create("JIT-JITServerClassMapMonitor");
+   _DLTSetMonitor = TR::Monitor::create("JIT-JITServerDLTSetMonitor");
    _classChainDataMapMonitor = TR::Monitor::create("JIT-JITServerClassChainDataMapMonitor");
    _sequencingMonitor = TR::Monitor::create("JIT-JITServerSequencingMonitor");
    _cacheInitMonitor = TR::Monitor::create("JIT-JITServerCacheInitMonitor");
@@ -124,6 +126,7 @@ ClientSessionData::destroyMonitors()
    {
    TR::Monitor::destroy(_romMapMonitor);
    TR::Monitor::destroy(_classMapMonitor);
+   TR::Monitor::destroy(_DLTSetMonitor);
    TR::Monitor::destroy(_classChainDataMapMonitor);
    TR::Monitor::destroy(_sequencingMonitor);
    TR::Monitor::destroy(_cacheInitMonitor);
@@ -230,7 +233,17 @@ ClientSessionData::processUnloadedClasses(const std::vector<TR_OpaqueClassBlock*
             }
 
          J9Method *methods = it->second._methodsOfClass;
-         // delete all the cached J9Methods belonging to this unloaded class
+            {
+            // Delete unloaded j9methods from the set of DLTed methods.
+            OMR::CriticalSection cs(getDLTSetMonitor());
+            for (size_t i = 0; i < romClass->romMethodCount; i++)
+               {
+               J9Method *j9method = methods + i;
+               _DLTedMethodSet.erase(j9method);
+               }
+            } // end critical section getDLTSetMonitor()
+
+         // Delete all the cached J9Methods belonging to this unloaded class.
          for (size_t i = 0; i < romClass->romMethodCount; i++)
             {
             J9Method *j9method = methods + i;
@@ -260,7 +273,7 @@ ClientSessionData::processUnloadedClasses(const std::vector<TR_OpaqueClassBlock*
          {
          purgeCache(unloadedClasses, _classRecordMap, &ClassUnloadedData::_record);
          }
-      }
+      } // end critical section getROMMapMonitor()
 
    // remove the class chain data from the cache for the unloaded class.
    {
@@ -1429,6 +1442,8 @@ ClientSessionData::clearCaches(bool locked)
 
    _romClassMap.clear();
 
+   _DLTedMethodSet.clear();
+
    _classChainDataMap.clear();
    _constantPoolToClassMap.clear();
 

runtime/compiler/runtime/JITClientSession.hpp

@@ -404,13 +404,15 @@ class ClientSessionData
    PersistentUnorderedMap<J9Class *, ClassInfo> &getROMClassMap() { return _romClassMap; }
    PersistentUnorderedMap<J9Method *, J9MethodInfo> &getJ9MethodMap() { return _J9MethodMap; }
    PersistentUnorderedMap<ClassLoaderStringPair, TR_OpaqueClassBlock *> &getClassBySignatureMap() { return _classBySignatureMap; }
+   PersistentUnorderedSet<J9Method*> &getDLTedMethodSet() { return _DLTedMethodSet; }
    PersistentUnorderedMap<J9Class *, ClassChainData> &getClassChainDataMap() { return _classChainDataMap; }
    PersistentUnorderedMap<J9ConstantPool *, TR_OpaqueClassBlock *> &getConstantPoolToClassMap() { return _constantPoolToClassMap; }
    void initializeUnloadedClassAddrRanges(const std::vector<TR_AddressRange> &unloadedClassRanges, int32_t maxRanges);
    void processUnloadedClasses(const std::vector<TR_OpaqueClassBlock*> &classes, bool updateUnloadedClasses);
    void processIllegalFinalFieldModificationList(const std::vector<TR_OpaqueClassBlock*> &classes);
    TR::Monitor *getROMMapMonitor() { return _romMapMonitor; }
    TR::Monitor *getClassMapMonitor() { return _classMapMonitor; }
+   TR::Monitor *getDLTSetMonitor() { return _DLTSetMonitor; }
    TR::Monitor *getClassChainDataMapMonitor() { return _classChainDataMapMonitor; }
    TR_IPBytecodeHashTableEntry *getCachedIProfilerInfo(TR_OpaqueMethodBlock *method, uint32_t byteCodeIndex, bool *methodInfoPresent);
    bool cacheIProfilerInfo(TR_OpaqueMethodBlock *method, uint32_t byteCodeIndex, TR_IPBytecodeHashTableEntry *entry, bool isCompiled);
@@ -421,7 +423,7 @@ class ClientSessionData
    bool loadBytecodeDataFromSharedProfileCache(J9Method *method, bool stable, TR::Compilation *comp, const std::string &ipdata);
    bool storeBytecodeProfileInSharedRepository(TR_OpaqueMethodBlock *method, const std::string &ipdata, uint64_t numSamples, bool isStable, TR::Compilation *);
    VMInfo *getOrCacheVMInfo(JITServer::ServerStream *stream);
-   void clearCaches(bool locked=false); // destroys _chTableClassMap, _romClassMap, _J9MethodMap and _unloadedClassAddresses
+   void clearCaches(bool locked=false); // destroys _chTableClassMap, _romClassMap, _J9MethodMap, _unloadedClassAddresses and _DLTedMethodSet
    void clearCachesLocked(TR_J9VMBase *fe);
    bool cachesAreCleared() const { return _requestUnloadedClasses; }
    void setCachesAreCleared(bool b) { _requestUnloadedClasses = b; }
@@ -580,12 +582,15 @@ class ClientSessionData
    // The following hashtable caches <classname> --> <J9Class> mappings
    // All classes in here are loaded by the systemClassLoader so we know they cannot be unloaded
    PersistentUnorderedMap<ClassLoaderStringPair, TR_OpaqueClassBlock*> _classBySignatureMap;
+   // The set of j9methods that have been DLTed. This may be queried by the Inliner. Protected by _DLTSetMonitor.
+   PersistentUnorderedSet<J9Method*> _DLTedMethodSet;
 
    PersistentUnorderedMap<J9Class *, ClassChainData> _classChainDataMap;
    //Constant pool to class map
    PersistentUnorderedMap<J9ConstantPool *, TR_OpaqueClassBlock *> _constantPoolToClassMap;
    TR::Monitor *_romMapMonitor;
    TR::Monitor *_classMapMonitor;
+   TR::Monitor *_DLTSetMonitor; // Protects the set of methods that have been DLTed: _DLTedMethodSet
    TR::Monitor *_classChainDataMapMonitor;
    // The following monitor is used to protect access to _lastProcessedCriticalSeqNo and
    // the list of out-of-sequence compilation requests (_OOSequenceEntryList)