Merge pull request #18948 from cjjdespres/new-deserializer

Implement a deserializer and shared cache interface that ignores the local SCC

Author: mpirvu

runtime/compiler/control/CompilationThread.cpp

@@ -2319,6 +2319,7 @@ bool TR::CompilationInfo::shouldRetryCompilation(TR_MethodToBeCompiled *entry, T
             case compilationStreamVersionIncompatible:
             case compilationStreamLostMessage:
             case aotCacheDeserializationFailure:
+            case aotDeserializerReset:
 #endif
             case compilationInterrupted:
             case compilationCodeReservationFailure:
@@ -11702,6 +11703,10 @@ TR::CompilationInfoPerThreadBase::processException(
       {
       // error code was already set in remoteCompile()
       }
+   catch (const J9::AOTDeserializerReset &e)
+      {
+      _methodBeingCompiled->_compErrCode = aotDeserializerReset;
+      }
 #endif /* defined(J9VM_OPT_JITSERVER) */
    catch (...)
       {

runtime/compiler/control/rossa.cpp

@@ -212,6 +212,7 @@ const char *compilationErrorNames[]={
    "compilationStreamVersionIncompatible",                 // compilationFirstJITServerFailure + 3 = 51
    "compilationStreamInterrupted",                         // compilationFirstJITServerFailure + 4 = 52
    "aotCacheDeserializationFailure",                       // compilationFirstJITServerFailure + 5 = 53
+   "aotDeserializerReset",                                 // compilationFirstJITServerFailure + 6 = 54
 #endif /* defined(J9VM_OPT_JITSERVER) */
    "compilationMaxError"
 };

runtime/compiler/control/rossa.h

@@ -82,6 +82,7 @@ typedef enum {
    compilationStreamVersionIncompatible                 = compilationFirstJITServerFailure + 3, // 51
    compilationStreamInterrupted                         = compilationFirstJITServerFailure + 4, // 52
    aotCacheDeserializationFailure                       = compilationFirstJITServerFailure + 5, // 53
+   aotDeserializerReset                                 = compilationFirstJITServerFailure + 6, // 54
 #endif /* defined(J9VM_OPT_JITSERVER) */
 
    /* must be the last one */

runtime/compiler/env/ClassLoaderTable.cpp

@@ -382,6 +382,20 @@ TR_PersistentClassLoaderTable::lookupClassLoaderAndChainAssociatedWithClassName(
    return { info->_loader, info->_chain };
    }
 
+void *
+TR_PersistentClassLoaderTable::lookupClassLoaderAssociatedWithClassName(const uint8_t *data, size_t length) const
+   {
+   assertCurrentThreadCanRead();
+
+   NameKey key { data, length };
+   size_t index;
+   TR_ClassLoaderInfo *prev;
+   TR_ClassLoaderInfo *info = lookup<Name>(_nameTable, index, prev, &key);
+   if (!info)
+      return NULL;
+   return info->_loader;
+   }
+
 const J9UTF8 *
 TR_PersistentClassLoaderTable::lookupClassNameAssociatedWithClassLoader(void *loader) const
    {

runtime/compiler/env/ClassLoaderTable.hpp

@@ -46,6 +46,7 @@ class TR_PersistentClassLoaderTable
    // in order to support AOT method serialization (and caching at JITServer) and deserialization.
    std::pair<void *, void *>// loader, chain
    lookupClassLoaderAndChainAssociatedWithClassName(const uint8_t *data, size_t length) const;
+   void *lookupClassLoaderAssociatedWithClassName(const uint8_t *data, size_t length) const;
    const J9UTF8 *lookupClassNameAssociatedWithClassLoader(void *loader) const;
 #endif /* defined(J9VM_OPT_JITSERVER) */
    void removeClassLoader(J9VMThread *vmThread, void *loader);

runtime/compiler/env/J9SharedCache.cpp

@@ -45,6 +45,7 @@
 #if defined(J9VM_OPT_JITSERVER)
 #include "control/JITServerHelpers.hpp"
 #include "runtime/JITClientSession.hpp"
+#include "runtime/JITServerAOTDeserializer.hpp"
 #endif
 
 #define LOG(logLevel, format, ...)               \
@@ -148,7 +149,10 @@ TR_J9SharedCache::TR_J9SharedCache(TR_J9VMBase *fe)
    _numDigitsForCacheOffsets = 8;
 
 #if defined(J9VM_OPT_JITSERVER)
-   TR_ASSERT_FATAL(_sharedCacheConfig || _compInfo->getPersistentInfo()->getRemoteCompilationMode() == JITServer::SERVER, "Must have _sharedCacheConfig");
+   TR_ASSERT_FATAL(_sharedCacheConfig || _compInfo->getPersistentInfo()->getRemoteCompilationMode() == JITServer::SERVER
+                                      || (_compInfo->getPersistentInfo()->getRemoteCompilationMode() == JITServer::CLIENT
+                                          && _compInfo->getPersistentInfo()->getJITServerUseAOTCache()),
+                  "Must have _sharedCacheConfig");
 #else
    TR_ASSERT_FATAL(_sharedCacheConfig, "Must have _sharedCacheConfig");
 #endif
@@ -1647,4 +1651,108 @@ TR_J9JITServerSharedCache::storeSharedData(J9VMThread *vmThread, const char *key
    return std::get<0>(_stream->read<const void *>());
    }
 
+TR_J9DeserializerSharedCache::TR_J9DeserializerSharedCache(TR_J9VMBase *fe, JITServerNoSCCAOTDeserializer *deserializer)
+   : TR_J9SharedCache(fe)
+   {
+   _deserializer = deserializer;
+   }
+
+J9ROMClass *
+TR_J9DeserializerSharedCache::romClassFromOffsetInSharedCache(uintptr_t offset)
+   {
+   TR::Compilation *comp = TR::compInfoPT->getCompilation();
+   bool wasReset = false;
+   auto romClass = _deserializer->romClassFromOffsetInSharedCache(offset, comp, wasReset);
+   if (wasReset)
+      comp->failCompilation<J9::AOTDeserializerReset>(
+         "Deserializer reset during relocation of method %s", comp->signature());
+   TR_ASSERT_FATAL(romClass, "ROM class for offset %zu could not be found",
+                   offset,
+                   JITServerNoSCCAOTDeserializer::offsetId(offset),
+                   JITServerNoSCCAOTDeserializer::offsetType(offset));
+   return romClass;
+   }
+
+void *
+TR_J9DeserializerSharedCache::pointerFromOffsetInSharedCache(uintptr_t offset)
+   {
+   TR::Compilation *comp = TR::compInfoPT->getCompilation();
+   bool wasReset = false;
+   auto ptr = _deserializer->pointerFromOffsetInSharedCache(offset, comp, wasReset);
+   if (wasReset)
+      comp->failCompilation<J9::AOTDeserializerReset>(
+         "Deserializer reset during relocation of method %s", comp->signature());
+   TR_ASSERT_FATAL(ptr, "Pointer for offset %zu ID %zu type %u could not be found",
+                   offset,
+                   JITServerNoSCCAOTDeserializer::offsetId(offset),
+                   JITServerNoSCCAOTDeserializer::offsetType(offset));
+   return ptr;
+   }
+
+void *
+TR_J9DeserializerSharedCache::lookupClassLoaderAssociatedWithClassChain(void *chainData)
+   {
+   // We return chainData directly because the only thing this function can be called on is the result of
+   // TR_J9DeserializerSharedCache::pointerFromOffsetInSharedCache(), and that will return a (J9ClassLoader *)
+   // directly when given a class loader offset.
+   return chainData;
+   }
+
+bool
+TR_J9DeserializerSharedCache::classMatchesCachedVersion(J9Class *clazz, UDATA *chainData)
+   {
+   // During deserialization, we find a matching J9Class for the first entry of the chainData, meaning that
+   // its ROM class chain matches what was recorded during compilation. This provides the same guarantees
+   // that TR_J9SharedCache::validateClassChain() does, which is what TR_J9SharedCache::validateClassChain()
+   // uses to verify that the given clazz matches chainData. Thus we only have to check that that cached J9Class
+   // is equal to the one we are trying to validate.
+   TR::Compilation *comp = TR::compInfoPT->getCompilation();
+   bool wasReset = false;
+   auto ramClass = _deserializer->classFromOffset(chainData[1], comp, wasReset);
+   if (wasReset)
+      comp->failCompilation<J9::AOTDeserializerReset>(
+         "Deserializer reset during relocation of method %s", comp->signature());
+   TR_ASSERT_FATAL(ramClass, "RAM class for offset %zu ID %zu type %zu could not be found",
+                   chainData[1],
+                   JITServerNoSCCAOTDeserializer::offsetId(chainData[1]),
+                   JITServerNoSCCAOTDeserializer::offsetType(chainData[1]));
+   return ramClass == clazz;
+   }
+
+TR_OpaqueClassBlock *
+TR_J9DeserializerSharedCache::lookupClassFromChainAndLoader(uintptr_t *chainData, void *classLoader)
+   {
+   // The base TR_J9SharedCache::lookupClassFromChainAndLoader(), when given a class chain and class loader, will look in the loader
+   // a J9Class correspoding to the first class in the chain. If one could be found, it then verifies that the class matches the cached version.
+   // We do not need to perform that checking here, because during deserialization we will have already resolved the first class in the chain to
+   // a J9Class and verified that it matches. Thus we can simply return that cached first J9Class.
+   TR::Compilation *comp = TR::compInfoPT->getCompilation();
+   bool wasReset = false;
+   auto clazz = _deserializer->classFromOffset(chainData[1], comp, wasReset);
+   if (wasReset)
+      comp->failCompilation<J9::AOTDeserializerReset>(
+         "Deserializer reset during relocation of method %s", comp->signature());
+   TR_ASSERT_FATAL(clazz, "Class for offset %zu could not be found",
+                   chainData[1],
+                   JITServerNoSCCAOTDeserializer::offsetId(chainData[1]),
+                   JITServerNoSCCAOTDeserializer::offsetType(chainData[1]));
+   return reinterpret_cast<TR_OpaqueClassBlock *>(clazz);
+   }
+
+J9ROMMethod *
+TR_J9DeserializerSharedCache::romMethodFromOffsetInSharedCache(uintptr_t offset)
+   {
+   TR::Compilation *comp = TR::compInfoPT->getCompilation();
+   bool wasReset = false;
+   auto romMethod = _deserializer->romMethodFromOffsetInSharedCache(offset, comp, wasReset);
+   if (wasReset)
+      comp->failCompilation<J9::AOTDeserializerReset>(
+         "Deserializer reset during relocation of method %s", comp->signature());
+   TR_ASSERT_FATAL(romMethod, "ROM method for offset %zu ID %zu type %zu could not be found",
+                   offset,
+                   JITServerNoSCCAOTDeserializer::offsetId(offset),
+                   JITServerNoSCCAOTDeserializer::offsetType(offset));
+   return romMethod;
+   }
+
 #endif

runtime/compiler/env/J9SharedCache.hpp

@@ -39,6 +39,7 @@ namespace TR { class CompilationInfo; }
 #if defined(J9VM_OPT_JITSERVER)
 namespace TR { class CompilationInfoPerThread; }
 namespace JITServer { class ServerStream; }
+class JITServerNoSCCAOTDeserializer;
 #endif
 
 struct J9SharedClassConfig;
@@ -106,6 +107,10 @@ class TR_J9SharedCache : public TR_SharedCache
     * \brief Converts a shared cache offset, calculated from the end of the SCC, into the
     *        metadata section of the SCC into a pointer.
     *
+    * The pointer returned from this function should be considered opaque by the consumers of this API,
+    * as some subclasses (like TR_J9DeserializerSharedCache) might not return, say, an actual (uintptr *) class chain
+    * given an offset that is ostensibly to such a chain.
+    *
     * \param[in] offset The offset to convert.
     * \return A pointer. Raises a fatal assertion before returning NULL if the offset is invalid.
     */
@@ -689,6 +694,80 @@ class TR_J9JITServerSharedCache : public TR_J9SharedCache
    JITServer::ServerStream *_stream;
    TR::CompilationInfoPerThread *_compInfoPT;
    };
+
+/**
+* \class TR_J9DeserializerSharedCache
+* \brief Class used by a JITServer client for querying the deserializer during AOT cache loads
+*
+* This class is an extension of the TR_J9SharedCache class which overrides a number
+* of TR_J9SharedCache's APIs. TR_J9DeserializerSharedCache is used by a client of a JITServer
+* when relocating a method received from the JITServer's AOT cache. It ignores any local shared cache
+* that may exist, and instead will query the JITServerNoSCCAOTDeserializer during relocation, fetching the
+* deserializer's cached information.
+*
+* The offsets used by this class are different from those of the other TR_J9SharedCache classes and their derivatives;
+* they are the idAndType of the AOTSerializationRecord records maintained by a JITServer's AOT cache, and don't
+* correspond to any storage location of the entities that the offsets refer to.
+*/
+class TR_J9DeserializerSharedCache : public TR_J9SharedCache
+   {
+public:
+   TR_ALLOC(TR_Memory::SharedCache)
+
+   TR_J9DeserializerSharedCache(TR_J9VMBase *fe, JITServerNoSCCAOTDeserializer *deserializer);
+
+   virtual void *pointerFromOffsetInSharedCache(uintptr_t offset) override;
+   virtual void *lookupClassLoaderAssociatedWithClassChain(void *chainData) override;
+   virtual J9ROMClass *romClassFromOffsetInSharedCache(uintptr_t offset) override;
+   virtual J9ROMMethod *romMethodFromOffsetInSharedCache(uintptr_t offset) override;
+   virtual bool classMatchesCachedVersion(J9Class *clazz, UDATA *chainData=NULL) override;
+   virtual TR_OpaqueClassBlock *lookupClassFromChainAndLoader(uintptr_t *chainData, void *classLoader) override;
+
+   virtual bool isHint(TR_ResolvedMethod *, TR_SharedCacheHint, uint16_t *dataField = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual bool isHint(J9Method *, TR_SharedCacheHint, uint16_t *dataField = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual uint16_t getAllEnabledHints(J9Method *method) override { TR_ASSERT_FATAL(false, "called"); return 0; }
+   virtual void addHint(J9Method *, TR_SharedCacheHint) override { TR_ASSERT_FATAL(false, "called"); }
+   virtual void addHint(TR_ResolvedMethod *, TR_SharedCacheHint) override { TR_ASSERT_FATAL(false, "called"); }
+   virtual bool isMostlyFull() override { TR_ASSERT_FATAL(false, "called"); return false; }
+
+   virtual uintptr_t offsetInSharedCacheFromPointer(void *ptr) override { TR_ASSERT_FATAL(false, "called"); return 0; }
+   virtual uintptr_t offsetInSharedCacheFromROMClass(J9ROMClass *romClass) override { TR_ASSERT_FATAL(false, "called"); return 0; }
+   virtual uintptr_t offsetInSharedCacheFromROMMethod(J9ROMMethod *romMethod) override { TR_ASSERT_FATAL(false, "called"); return 0; }
+   virtual void *ptrToROMClassesSectionFromOffsetInSharedCache(uintptr_t offset) override { TR_ASSERT_FATAL(false, "called"); return NULL; }
+   virtual uintptr_t offsetInSharedCacheFromPtrToROMClassesSection(void *ptr) override { TR_ASSERT_FATAL(false, "called"); return 0; }
+
+   virtual void persistIprofileInfo(TR::ResolvedMethodSymbol *, TR::Compilation *comp) override { TR_ASSERT_FATAL(false, "called"); }
+   virtual void persistIprofileInfo(TR::ResolvedMethodSymbol *, TR_ResolvedMethod*, TR::Compilation *comp) override { TR_ASSERT_FATAL(false, "called"); }
+
+   virtual bool canRememberClass(TR_OpaqueClassBlock *classPtr) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual uintptr_t rememberClass(TR_OpaqueClassBlock *classPtr,
+                                   const AOTCacheClassChainRecord **classChainRecord = NULL) override
+      { TR_ASSERT_FATAL(false, "called"); return TR_SharedCache::INVALID_CLASS_CHAIN_OFFSET; }
+
+   virtual uintptr_t rememberClass(J9Class *clazz, const AOTCacheClassChainRecord **classChainRecord = NULL,
+                                   bool create = true) override
+      { TR_ASSERT_FATAL(false, "called"); return TR_SharedCache::INVALID_CLASS_CHAIN_OFFSET; }
+
+   virtual UDATA rememberDebugCounterName(const char *name) override { TR_ASSERT_FATAL(false, "called"); return 0; }
+   virtual const char *getDebugCounterName(UDATA offset) override { TR_ASSERT_FATAL(false, "called"); return NULL; }
+
+   virtual bool isPointerInSharedCache(void *ptr, uintptr_t *cacheOffset = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual bool isOffsetInSharedCache(uintptr_t encoded_offset, void *ptr = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual bool isROMClassInSharedCache(J9ROMClass *romClass, uintptr_t *cacheOffset = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual bool isROMClassOffsetInSharedCache(uintptr_t offset, J9ROMClass **romClassPtr = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual bool isROMMethodInSharedCache(J9ROMMethod *romMethod, uintptr_t *cacheOffset = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual bool isROMMethodOffsetInSharedCache(uintptr_t offset, J9ROMMethod **romMethodPtr = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual bool isPtrToROMClassesSectionInSharedCache(void *ptr, uintptr_t *cacheOffset = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual bool isOffsetOfPtrToROMClassesSectionInSharedCache(uintptr_t offset, void **ptr = NULL) override { TR_ASSERT_FATAL(false, "called"); return false; }
+   virtual uintptr_t getClassChainOffsetIdentifyingLoader(TR_OpaqueClassBlock *clazz, uintptr_t **classChain = NULL) override { TR_ASSERT_FATAL(false, "called"); return 0; }
+   virtual const void *storeSharedData(J9VMThread *vmThread, const char *key, const J9SharedDataDescriptor *descriptor) override { TR_ASSERT_FATAL(false, "called"); return NULL; }
+
+   virtual J9SharedClassCacheDescriptor *getCacheDescriptorList() override { TR_ASSERT_FATAL(false, "called"); return NULL; }
+
+private:
+   JITServerNoSCCAOTDeserializer *_deserializer;
+   };
+
 #endif /* defined(J9VM_OPT_JITSERVER) */
 
 #endif

runtime/compiler/exceptions/AOTFailure.hpp

@@ -148,6 +148,16 @@ class AOTCacheDeserializationFailure : public virtual RuntimeFailure
    {
    virtual const char *what() const throw() { return "AOT cache deserialization failure"; }
    };
+
+/**
+ * JITServer AOT Deserializer Reset exception type.
+ *
+ * Thrown when a concurrent JITServer AOT deserializer reset has been detected.
+ */
+class AOTDeserializerReset : public virtual RuntimeFailure
+   {
+   virtual const char *what() const throw() { return "AOT deserializer reset"; }
+   };
 #endif /* defined(J9VM_OPT_JITSERVER) */
 }