Merge remote-tracking branch 'origin/candidate-10.2.x'

Signed-off-by: Gordon Smith <GordonJSmith@gmail.com>

Author: GordonSmith

.github/workflows/build-clienttools-macos-14.yml

@@ -129,6 +129,6 @@ jobs:
         if: ${{ failure() || cancelled() }}
         uses: actions/upload-artifact@v4
         with:
-          name: macos-13-clienttools-logs-${{ github.job }}-${{ github.run_number }}
+          name: macos-14-clienttools-logs-${{ github.job }}-${{ github.run_number }}
           path: ./build/**/*.log
           retention-days: 1

CMakeLists.txt

@@ -305,6 +305,12 @@ if(TOP_LEVEL_PROJECT)
         else(${ARCH64BIT} EQUAL 1)
             set(CPACK_RPM_PACKAGE_ARCHITECTURE "i386")
         endif(${ARCH64BIT} EQUAL 1)
+    elseif(APPLE)
+        if (CMAKE_OSX_ARCHITECTURES MATCHES "x86_64")
+            set(CPACK_RPM_PACKAGE_ARCHITECTURE "x86_64")
+        else()
+            set(CPACK_RPM_PACKAGE_ARCHITECTURE "arm64")
+        endif()
     else(WIN32)
         set(CPACK_RPM_PACKAGE_ARCHITECTURE ${CMAKE_SYSTEM_PROCESSOR})
         if("${CPACK_RPM_PACKAGE_ARCHITECTURE}" STREQUAL "i686")

common/eventconsumption/eventindexhotspot.cpp

@@ -42,87 +42,90 @@ class CHotspotEventVisitor : public CInterfaceOf<IEventVisitor>
             Range range{std::numeric_limits<bucket_type>::max(), 0};
 
             Activity() = default;
+
             bool hasActivity() const
             {
                 return !buckets.empty();
             }
+
+            void recordEvent(bucket_type bucket)
+            {
+                bucket_type key = bucket2activityKey(bucket);
+                unsigned short index = bucket2activityIndex(bucket);
+                buckets[key][index]++;
+                if (bucket < range.first)
+                    range.first = bucket;
+                if (bucket > range.second)
+                    range.second = bucket;
+            }
+
+            void forEachBucket(IBucketVisitor& visitor, NodeKind nodeKind)
+            {
+                if (!hasActivity())
+                    return;
+                for (bucket_type bucket = range.first; bucket <= range.second; bucket++)
+                {
+                    stat_type events = queryBucket(buckets, bucket);
+                    if (events)
+                        visitor.visitBucket(bucket, nodeKind, events);
+                }
+            }
+
+        protected:
+            bucket_type bucket2activityKey(offset_t bucket)
+            {
+                return bucket >> bucketArrayBits;
+            }
+
+            unsigned short bucket2activityIndex(offset_t bucket)
+            {
+                return bucket & bucketArrayMask;
+            }
+
+            stat_type queryBucket(const Buckets& buckets, bucket_type bucket)
+            {
+                Buckets::const_iterator it = buckets.find(bucket2activityKey(bucket));
+                if (it != buckets.end())
+                    return it->second[bucket2activityIndex(bucket)];
+                return 0;
+            }
         };
     public:
-        CActivity(CHotspotEventVisitor& _container, __uint64 _id)
-            : container(_container)
+        CActivity(CMetaInfoState& _metaInfoState, __uint64 _id)
+            : metaInfoState(_metaInfoState)
             , id(_id)
         {
         }
 
-        void recordEvent(offset_t offset, NodeKind nodeKind)
+        void recordEvent(offset_t offset, NodeKind nodeKind, byte granularityBits)
         {
-            bucket_type bucket = page2bucket(offset2page(offset, defaultPageBits), granularityBits());
-            bucket_type key = bucket2activityKey(bucket);
-            unsigned short index = bucket2activityIndex(bucket);
-            activity[nodeKind].buckets[key][index]++;
-            if (bucket < activity[nodeKind].range.first)
-                activity[nodeKind].range.first = bucket;
-            if (bucket > activity[nodeKind].range.second)
-                activity[nodeKind].range.second = bucket;
+            activity[nodeKind].recordEvent(page2bucket(offset2page(offset, defaultPageBits), granularityBits));
         }
 
         void forEachBucket(IBucketVisitor& visitor)
         {
-            const char* path = container.operation.queryMetaInfoState().queryFilePath(id);
             if (!hasActivity()) // suppress inactive files
                 return;
+            const char* path = metaInfoState.queryFilePath(id);
             visitor.arrive(id, path);
             for (unsigned kind = 0; kind < NumNodeKinds; kind++)
-            {
-                Activity& act = activity[kind];
-                if (act.hasActivity())
-                {
-                    for (bucket_type bucket = act.range.first; bucket <= act.range.second; bucket++)
-                    {
-                        stat_type events = queryBucket(act.buckets, bucket);
-                        if (events)
-                            visitor.visitBucket(bucket, NodeKind(kind), events);
-                    }
-                }
-            }
+                activity[kind].forEachBucket(visitor, NodeKind(kind));
             visitor.depart();
         }
 
     protected:
-        inline byte granularityBits() const
-        {
-            return container.granularityBits;
-        }
-        inline bucket_type bucket2activityKey(offset_t bucket)
-        {
-            return bucket >> bucketArrayBits;
-        }
-
-        inline unsigned short bucket2activityIndex(offset_t bucket)
-        {
-            return bucket & bucketArrayMask;
-        }
-
-        stat_type queryBucket(const Buckets& buckets, bucket_type bucket)
-        {
-            Buckets::const_iterator it = buckets.find(bucket2activityKey(bucket));
-            if (it != buckets.end())
-                return it->second[bucket2activityIndex(bucket)];
-            return 0;
-        }
-
         bool hasActivity() const
         {
-            for (const Activity& act : activity)
+            for (unsigned kind = 0; kind < NumNodeKinds; kind++)
             {
-                if (act.hasActivity())
+                if (activity[kind].hasActivity())
                     return true;
             }
             return false;
         }
 
     private:
-        CHotspotEventVisitor& container; // back reference to obtain shared configuration
+        CMetaInfoState& metaInfoState;
         __uint64 id{0};
         Activity activity[NumNodeKinds];
     };
@@ -135,41 +138,43 @@ class CHotspotEventVisitor : public CInterfaceOf<IEventVisitor>
 
     virtual bool visitEvent(CEvent& event) override
     {
-        if (event.hasAttribute(EvAttrFileId))
-        {
-            EventType type = event.queryType();
-            if (type == MetaFileInformation || observedEvents.count(type) == 0)
-                return true;
-            __uint64 fileId = event.queryNumericValue(EvAttrFileId);
-            auto [it, inserted] = activity.try_emplace(fileId, *this, fileId);
-            NodeKind nodeKind = queryIndexNodeKind(event);
-            it->second.recordEvent(event.queryNumericValue(EvAttrFileOffset), nodeKind);
-        }
+        EventType type = event.queryType();
+        if (MetaFileInformation == type)
+            return true;
+        if (observedEvents.find(type) == observedEvents.end())
+            return true;
+        __uint64 fileId = event.queryNumericValue(EvAttrFileId);
+        NodeKind nodeKind = queryIndexNodeKind(event);
+        auto [it, inserted] = activity.try_emplace(fileId, operation.queryMetaInfoState(), fileId);
+        it->second.recordEvent(event.queryNumericValue(EvAttrFileOffset), nodeKind, granularityBits);
         return true;
     }
 
-    virtual void departFile(uint32_t bytesRead) override
+    virtual void departFile(uint32_t) override
     {
-        analyzer->begin(observedEvents, granularityBits);
-        for (auto& [fileId, activity] : activity)
-            activity.forEachBucket(*analyzer);
-        analyzer->end();
+        // Intentionally empty.
     }
 
 public:
-    CHotspotEventVisitor(CIndexHotspotOp& _operation, IBucketVisitor& _analyzer, const std::set<EventType>& _observedEvents, byte _granularityBits)
+    CHotspotEventVisitor(CIndexHotspotOp& _operation, const std::set<EventType>& _observedEvents, byte _granularityBits)
         : operation(_operation)
-        , analyzer(&_analyzer)
         , granularityBits(_granularityBits)
         , observedEvents(_observedEvents)
     {
     }
 
+    void generateReport(IBucketVisitor& analyzer)
+    {
+        analyzer.begin(observedEvents, granularityBits);
+        for (auto& [fileId, activity] : activity)
+            activity.forEachBucket(analyzer);
+        analyzer.end();
+    }
+
 private:
     CIndexHotspotOp& operation;
     // map file id (as __uint64 due to visitor interface) to index activity
     using Activity = std::map<__uint64, CActivity>;
-    Linked<IBucketVisitor> analyzer;
     byte granularityBits{0};
     Activity activity;
     std::set<EventType> observedEvents;
@@ -182,14 +187,18 @@ bool CIndexHotspotOp::ready() const
 
 bool CIndexHotspotOp::doOp()
 {
-    Owned<IBucketVisitor> analyzer;
-    if (limit)
-        analyzer.setown(createTopBucketVisitor(*out, limit));
-    else
-        analyzer.setown(createAllBucketVisitor(*out));
-
-    CHotspotEventVisitor visitor(*this, *analyzer, observedEvents, granularityBits);
-    return traverseEvents(inputPath, visitor);
+    Owned<CHotspotEventVisitor> visitor = new CHotspotEventVisitor(*this, observedEvents, granularityBits);
+    if (traverseEvents(inputPath, *visitor))
+    {
+        Owned<IBucketVisitor> analyzer;
+        if (limit)
+            analyzer.setown(createTopBucketVisitor(*out, limit));
+        else
+            analyzer.setown(createAllBucketVisitor(*out));
+        visitor->generateReport(*analyzer);
+        return true;
+    }
+    return false;
 }
 
 void CIndexHotspotOp::addObservedEvent(EventType observedEvent)

dali/base/dasds.cpp

@@ -5278,7 +5278,7 @@ class CStoreHelper : implements IStoreHelper, public CInterface
     unsigned keepStores{0};
     SessionId mySessId{0};
     size32_t bufferSize{0};
-    bool saveBinary{false};
+    bool saveBinary{true};
     bool saveAsync{false};
 
     void clearStoreInfo(const char *base, const char *location, unsigned edition, CStoreInfo *storeInfo=NULL)
@@ -6270,7 +6270,7 @@ CCovenSDSManager::CCovenSDSManager(ICoven &_coven, const char *_dataPath, const
     clientProps->setPropBool("@serverIterAvailable", true);
     clientProps->setPropBool("@useAppendOpt", true);
     clientProps->setPropBool("@serverGetIdsAvailable", true);
-    bool saveBinary = config->getPropBool("@saveBinary", isDebugBuild());
+    bool saveBinary = config->getPropBool("@saveBinary", true);
     clientProps->setPropBool("@saveBinary", saveBinary);
     bool saveAsync = config->getPropBool("@saveAsync", true);
     clientProps->setPropBool("@saveAsync", saveAsync);

dali/base/dasds.hpp

@@ -277,7 +277,7 @@ enum
     SH_BackupErrorFiles     = 0x0004,
     SH_CheckNewDelta        = 0x0008,
 };
-extern da_decl IStoreHelper *createStoreHelper(const char *storeName, const char *location, const char *remoteBackupLocation, unsigned configFlags, unsigned keepStores=0, unsigned delay=5000, const bool *abort=nullptr, bool saveBinary=false, bool saveAsync=true);
+extern da_decl IStoreHelper *createStoreHelper(const char *storeName, const char *location, const char *remoteBackupLocation, unsigned configFlags, unsigned keepStores=0, unsigned delay=5000, const bool *abort=nullptr, bool saveBinary=true, bool saveAsync=true);
 extern da_decl bool applyXmlDeltas(IPropertyTree &root, IIOStream &stream, bool stopOnError=false);
 extern da_decl bool traceAllTransactions(); // server only
 extern da_decl bool traceSlowTransactions(unsigned thresholdMs); // server only

dali/sasha/sacoalescer.cpp

@@ -50,7 +50,7 @@ void coalesceDatastore(IPropertyTree *coalesceProps, bool force)
 
         offset_t minDeltaSize = force?0:coalesceProps->getPropInt64("@minDeltaSize", DEFAULT_MINDELTASIZE);
 
-        bool saveBinary = confProps.getPropBool("Client/@saveBinary", false);
+        bool saveBinary = confProps.getPropBool("Client/@saveBinary", true);
         bool saveAsync = confProps.getPropBool("Client/@saveAsync", true);
 
         for (;;) {