Merge pull request #21782 from mpirvu/shared-cache

JITServer profiling infra for CallGraph entries

Author: dsouzai

runtime/compiler/control/JITClientCompilationThread.cpp

@@ -35,6 +35,7 @@
 #include "env/j9methodServer.hpp"
 #include "env/JITServerPersistentCHTable.hpp"
 #include "env/JSR292Methods.h"
+#include "env/StackMemoryRegion.hpp"
 #include "env/TypeLayout.hpp"
 #include "env/ut_j9jit.h"
 #include "env/VerboseLog.hpp"
@@ -113,53 +114,69 @@ findField(J9VMThread *vmStruct, J9ConstantPool *constantPool, UDATA index, BOOLE
 static void
 handler_IProfiler_profilingSample(JITServer::ClientStream *client, TR_J9VM *fe, TR::Compilation *comp)
    {
-   auto recv = client->getRecvData<TR_OpaqueMethodBlock*, uint32_t, uintptr_t>();
+   auto recv = client->getRecvData<TR_OpaqueMethodBlock*, uint32_t, bool, bool>();
    auto method = std::get<0>(recv);
    auto bcIndex = std::get<1>(recv);
-   auto data = std::get<2>(recv); // data==1 means 'send info for 1 bytecode'; data==0 means 'send info for entire method if possible'
+   auto wholeMethodInfo = std::get<2>(recv); // 'send info for entire method if possible'
+   auto sharedProfile = std::get<3>(recv);
 
    JITClientIProfiler *iProfiler = (JITClientIProfiler *)fe->getIProfiler();
 
    bool isCompiled = TR::CompilationInfo::isCompiled((J9Method*)method);
+   bool isQueued = TR::CompilationInfo::getJ9MethodVMExtra((J9Method *)method) == J9_JIT_QUEUED_FOR_COMPILATION;
    bool isInProgress = comp->getMethodBeingCompiled()->getPersistentIdentifier() == method;
    bool abort = false;
-   // Used to tell the server if a profiled entry should be stored in persistent or heap memory
-   bool usePersistentCache = isCompiled || isInProgress;
-   bool wholeMethodInfo = data == 0;
+   // Used to tell the server if a profiled entry should be stored in persistent or heap memory.
+   // Note that if the method is queued for compilation, new interpreter samples will not be collected.
+   bool usePersistentCache = isCompiled || isInProgress || isQueued;
 
    if (wholeMethodInfo)
       {
       // Serialize all the information related to this method
-      abort = iProfiler->serializeAndSendIProfileInfoForMethod(method, comp, client, usePersistentCache, isCompiled);
+      abort = iProfiler->serializeAndSendIProfileInfoForMethod(method, comp, client, usePersistentCache, isCompiled, sharedProfile);
+      if (!abort)
+         return;
       }
-   if (!wholeMethodInfo || abort) // Send information just for this entry
+
+   // Send information just for this entry
+   std::vector<J9Class *> uncachedClasses;
+   std::vector<JITServerHelpers::ClassInfoTuple> classInfoTuples;
+   auto entry = iProfiler->profilingSample(method, bcIndex, comp, 0, /*addIt=*/false);
+   if (entry && !entry->isInvalid())
       {
-      auto entry = iProfiler->profilingSample(method, bcIndex, comp, data, false);
-      if (entry && !entry->isInvalid())
-         {
-         uint32_t canPersist = entry->canBeSerialized(comp->getPersistentInfo()); // This may lock the entry
-         if (canPersist == IPBC_ENTRY_CAN_PERSIST)
-            {
-            uint32_t bytes = entry->getBytesFootprint();
-            std::string entryBytes(bytes, '\0');
-            auto storage = (TR_IPBCDataStorageHeader*)&entryBytes[0];
-            uintptr_t methodStartAddress = (uintptr_t)TR::Compiler->mtd.bytecodeStart(method);
-            entry->serialize(methodStartAddress, storage, comp->getPersistentInfo());
-            client->write(JITServer::MessageType::IProfiler_profilingSample, entryBytes, false, usePersistentCache, isCompiled);
-            }
-         else
+      uint32_t canPersist = entry->canBeSerialized(comp->getPersistentInfo()); // This may lock the entry
+      if (canPersist == IPBC_ENTRY_CAN_PERSIST)
+         {
+         uint32_t bytes = entry->getBytesFootprint();
+         std::string entryBytes(bytes, '\0');
+         auto storage = (TR_IPBCDataStorageHeader*)&entryBytes[0];
+         uintptr_t methodStartAddress = (uintptr_t)TR::Compiler->mtd.bytecodeStart(method);
+         entry->serialize(methodStartAddress, storage, comp->getPersistentInfo());
+
+         // Collect info about the classes the server needs but does not yet have
+         auto cgEntry = entry->asIPBCDataCallGraph();
+         if (cgEntry && sharedProfile)
             {
-            client->write(JITServer::MessageType::IProfiler_profilingSample, std::string(), false, usePersistentCache, isCompiled);
+            uncachedClasses.reserve(NUM_CS_SLOTS);
+            classInfoTuples.reserve(NUM_CS_SLOTS);
+            iProfiler->gatherUncachedClassesUsedInCGEntry(cgEntry, comp, uncachedClasses, classInfoTuples);
             }
-         // Unlock the entry
-         if (auto callGraphEntry = entry->asIPBCDataCallGraph())
-            if (canPersist != IPBC_ENTRY_PERSIST_LOCK && callGraphEntry->isLocked())
-               callGraphEntry->releaseEntry();
+
+         uint64_t totalSamples = entry->getNumSamples();
+         client->write(JITServer::MessageType::IProfiler_profilingSample, entryBytes, totalSamples, (size_t)1, /*wholeMethod=*/false, usePersistentCache, isCompiled, uncachedClasses, classInfoTuples);
          }
-      else // No valid info for specified bytecode index
+      else
          {
-         client->write(JITServer::MessageType::IProfiler_profilingSample, std::string(), false, usePersistentCache, isCompiled);
+         client->write(JITServer::MessageType::IProfiler_profilingSample, std::string(), (uint64_t)0, (size_t)0, /*wholeMethod=*/false, usePersistentCache, isCompiled, uncachedClasses, classInfoTuples);
          }
+      // Unlock the entry
+      if (auto callGraphEntry = entry->asIPBCDataCallGraph())
+         if (canPersist != IPBC_ENTRY_PERSIST_LOCK && callGraphEntry->isLocked())
+            callGraphEntry->releaseEntry();
+      }
+   else // No valid info for specified bytecode index
+      {
+      client->write(JITServer::MessageType::IProfiler_profilingSample, std::string(), (uint64_t)0, (size_t)0, /*wholeMethod=*/false, usePersistentCache, isCompiled, uncachedClasses, classInfoTuples);
       }
    }
 
@@ -3002,20 +3019,97 @@ handleServerMessage(JITServer::ClientStream *client, TR_J9VM *fe, JITServer::Mes
          break;
       case MessageType::AOTCache_getROMClassBatch:
          {
+         // The server has asked about N classes but we may send ClassInfos for N+M classes with
+         // M being the number of base component classes that the server does not yet have.
+         // The classes for those extra elements are passed back in extraClasses.
+         std::vector<J9Class *> extraClasses;
          auto recv = client->getRecvData<std::vector<J9Class *>>();
-         auto &ramClasses = std::get<0>(recv);
-         std::vector<JITServerHelpers::ClassInfoTuple> classInfos;
+         auto &ramClasses = std::get<0>(recv); // The classses for which the server requests information
+
+         std::vector<JITServerHelpers::ClassInfoTuple> classInfos; // This will be filled and returned to server
          classInfos.reserve(ramClasses.size());
 
+         TR::StackMemoryRegion region(*trMemory);
+         Vector<J9Class *> baseComponentClasses(region); // Temporary storage for base classes of arrays
+         baseComponentClasses.reserve(ramClasses.size());
+         Vector<J9Class *> uncachedBaseComponentClasses(region); // Filtered set of base component classes
+
          for (J9Class *ramClass : ramClasses)
-            classInfos.push_back(JITServerHelpers::packRemoteROMClassInfo(ramClass, fe->vmThread(), trMemory, true));
+            {
+            classInfos.push_back(JITServerHelpers::packRemoteROMClassInfo(ramClass, vmThread, trMemory, true/*serializeClass*/));
+
+            // If this is an array class, remember its base component class for later
+            int32_t numDimensions = 0;
+            J9Class *baseComponent = (J9Class *)TR_J9VMBase::staticGetBaseComponentClass((TR_OpaqueClassBlock *)ramClass, numDimensions);
+            if (numDimensions)
+               baseComponentClasses.push_back(baseComponent);
+            }
 
+         // Determine which baseComponent classes the server does not yet have
+         uncachedBaseComponentClasses.reserve(baseComponentClasses.size());
+         if (!baseComponentClasses.empty())
             {
             OMR::CriticalSection cs(compInfo->getclassesCachedAtServerMonitor());
-            compInfo->getclassesCachedAtServer().insert(ramClasses.begin(), ramClasses.end());
+            const auto &classesCachedAtServer = compInfo->getclassesCachedAtServer();
+            for (J9Class *baseComponent : baseComponentClasses)
+               {
+               if (classesCachedAtServer.find(baseComponent) == classesCachedAtServer.end()) // server doesn't have it
+                  {
+                  uncachedBaseComponentClasses.push_back(baseComponent);
+                  }
+               }
             }
 
-         client->write(response, classInfos);
+         // Add the uncached baseComponent classes to the classInfos vector
+         extraClasses.reserve(uncachedBaseComponentClasses.size());
+         for (J9Class *baseComponent : uncachedBaseComponentClasses)
+            {
+            classInfos.push_back(JITServerHelpers::packRemoteROMClassInfo(baseComponent, vmThread, trMemory, true/*serializeClass*/));
+            extraClasses.push_back(baseComponent);
+            }
+
+         // Send the information to the server.
+         client->write(response, classInfos, extraClasses);
+
+         // Finally, update client's view of classes cached by the server.
+            {
+            OMR::CriticalSection cs(compInfo->getclassesCachedAtServerMonitor());
+            compInfo->getclassesCachedAtServer().insert(ramClasses.begin(), ramClasses.end());
+            compInfo->getclassesCachedAtServer().insert(uncachedBaseComponentClasses.begin(), uncachedBaseComponentClasses.end());
+            } // end critical section
+         }
+         break;
+
+      case MessageType::AOTCache_getRAMClassFromClassRecordBatch:
+         {
+         // Convert several AOT cache class IDs to this client's RAMClasses
+         auto recv = client->getRecvData<std::vector<uintptr_t>, std::string>();
+         auto &classIds = std::get<0>(recv); // vector of classIDs that need to be converted into j9classes
+         auto &recordsStr = std::get<1>(recv); // packed serialization records that the client is missing
+
+         std::vector<J9Class *> ramClasses;
+         ramClasses.reserve(classIds.size());
+
+         if (auto deserializer = compInfo->getJITServerAOTDeserializer())
+            {
+            bool wasReset = false;
+            deserializer->cacheRecords((const uint8_t *)recordsStr.data(), recordsStr.size(), comp,
+                                       /*ignoreFailures=*/true, wasReset);
+            if (!wasReset)
+               {
+               for (uintptr_t id : classIds)
+                  {
+                  J9Class *ramClass = deserializer->getRAMClass(id, comp, wasReset);
+                  if (wasReset)
+                     {
+                     ramClasses.clear();
+                     break;
+                     }
+                  ramClasses.push_back(ramClass); // possibly NULL
+                  }
+               }
+            }
+         client->write(response, ramClasses);
          }
          break;
       default:

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 = 79; // ID: Su+UK1Q5oJlgUkWIBA6f
+   static const uint16_t MINOR_NUMBER = 80; // ID: snCDuoE2+InCmAiOg6YU
    static const uint8_t PATCH_NUMBER = 0;
    static uint32_t CONFIGURATION_FLAGS;
 

runtime/compiler/net/MessageTypes.cpp

@@ -265,6 +265,7 @@ const char *messageNames[] =
    "KnownObjectTable_addFieldAddressFromBaseIndex",
    "KnownObjectTable_getFieldAddressData",
    "AOTCache_getROMClassBatch",
+   "AOTCache_getRAMClassFromClassRecordBatch",
    "AOTCacheMap_request",
    "AOTCacheMap_reply"
    };

runtime/compiler/net/MessageTypes.hpp

@@ -294,6 +294,7 @@ enum MessageType : uint16_t
    KnownObjectTable_getFieldAddressData,
 
    AOTCache_getROMClassBatch,
+   AOTCache_getRAMClassFromClassRecordBatch,
 
    AOTCacheMap_request,
    AOTCacheMap_reply,

runtime/compiler/runtime/IProfiler.cpp

@@ -976,6 +976,7 @@ TR_IProfiler::addSampleData(TR_IPBytecodeHashTableEntry *entry, uintptr_t data,
                // Overflow detected; divide both counters by 2
                existingData >>= 1;
                existingData &= 0x7FFF7FFF;
+               entry->setOverflow();
                }
 
             entry->setData(existingData + (1<<16));
@@ -988,6 +989,7 @@ TR_IProfiler::addSampleData(TR_IPBytecodeHashTableEntry *entry, uintptr_t data,
                // Overflow detected; divide both counters by 2
                existingData >>= 1;
                existingData &= 0x7FFF7FFF;
+               entry->setOverflow();
                }
 
             entry->setData(existingData + 1);
@@ -2759,7 +2761,10 @@ TR_IPBCDataCallGraph::setData(uintptr_t v, uint32_t freq)
          uint16_t oldWeight = _csInfo._weight[i];
          uint16_t newWeight = oldWeight + freq;
          if (newWeight < oldWeight)
-            newWeight = 0xFFFF;
+            {
+            newWeight = 0xFFFF; // capped to 0xFFFF
+            setOverflow();
+            }
          _csInfo._weight[i] = newWeight;
          returnCount = newWeight;
          found = true;
@@ -2783,8 +2788,11 @@ TR_IPBCDataCallGraph::setData(uintptr_t v, uint32_t freq)
       // Must update the `residue` bucket
       uint16_t oldResidueWeight = _csInfo._residueWeight;
       uint16_t newResidueWeight = oldResidueWeight + freq;
-      if (newResidueWeight > 0x7FFF)
+      if (newResidueWeight > 0x7FFF) // _residueWeight is kept on 15 bits
+         {
          newResidueWeight = 0x7FFF;
+         setOverflow();
+         }
       _csInfo._residueWeight = newResidueWeight;
       returnCount = newResidueWeight;
 
@@ -2803,6 +2811,7 @@ TR_IPBCDataCallGraph::setData(uintptr_t v, uint32_t freq)
             _csInfo.setClazz(0, v);
             _csInfo._residueWeight = 0;
             returnCount = freq;
+            setCountersWereReset();
             releaseEntry();
             }
          }
@@ -3001,7 +3010,7 @@ TR_IPBCDataCallGraph::canBeSerialized(TR::PersistentInfo *info)
 
 
 /**
- * API used by JITClient to serialize IP data of a method
+ * @brief API used by JITClient to serialize IP data of a method
  *
  * @param methodStartAddress Start address of the bytecodes for the method
  * @param storage Storage area where we serialize entries
@@ -3018,7 +3027,7 @@ TR_IPBCDataCallGraph::serialize(uintptr_t methodStartAddress, TR_IPBCDataStorage
    storage->ID = TR_IPBCD_CALL_GRAPH;
    storage->left = 0;
    storage->right = 0;
-   for (int32_t i=0; i < NUM_CS_SLOTS;i++)
+   for (int32_t i = 0; i < NUM_CS_SLOTS; i++)
       {
       J9Class *clazz = (J9Class *) _csInfo.getClazz(i);
       if (clazz)
@@ -4554,30 +4563,6 @@ TR_IPHashedCallSite::operator new (size_t size) throw()
    }
 
 
-uintptr_t CallSiteProfileInfo::getClazz(int index)
-   {
-   if (TR::Compiler->om.compressObjectReferences())
-      //support for convert code, when it is implemented, "uncompress"
-      return (uintptr_t)TR::Compiler->cls.convertClassOffsetToClassPtr((TR_OpaqueClassBlock *)(uintptr_t)_clazz[index]);
-   else
-      return (uintptr_t)_clazz[index]; //things are just stored as regular pointers otherwise
-   }
-
-
-void CallSiteProfileInfo::setClazz(int index, uintptr_t clazzPointer)
-   {
-   if (TR::Compiler->om.compressObjectReferences())
-      {
-      //support for convert code, when it is implemented, do compression
-      TR_OpaqueClassBlock * compressedOffset = J9JitMemory::convertClassPtrToClassOffset((J9Class *)clazzPointer); //compressed 32bit pointer
-      //if we end up with something in the top 32bits, our compression is no good...
-      TR_ASSERT((!(0xFFFFFFFF00000000 & (uintptr_t)compressedOffset)), "Class pointer contains bits in the top word. Pointer given: %p Compressed: %p", clazzPointer, compressedOffset);
-      _clazz[index] = (uint32_t)((uintptr_t)compressedOffset); //ditch the top zeros
-      }
-   else
-      _clazz[index] = (uintptr_t)clazzPointer;
-   }
-
 uintptr_t
 CallSiteProfileInfo::getDominantClass(int32_t &sumW, int32_t &maxW)
    {
@@ -4603,6 +4588,22 @@ CallSiteProfileInfo::getDominantClass(int32_t &sumW, int32_t &maxW)
    return data;
    }
 
+uint32_t
+CallSiteProfileInfo::getDominantSlot() const
+   {
+   uint32_t maxWeight = _residueWeight;
+   uint32_t maxIndex = NUM_CS_SLOTS;
+   for (uint32_t i = 0; i < NUM_CS_SLOTS; i++)
+      {
+      if (_weight[i] > maxWeight)
+         {
+         maxWeight = _weight[i];
+         maxIndex = i;
+         }
+      }
+   return maxIndex;
+   }
+
 // Supporting code for dumping IProfiler data to stderr to track possible
 // performance issues due to insufficient or wrong IProfiler info
 // Code is currently inactive. To actually use one must issue