Changes following review

Signed-off-by: Gavin Halliday <[email protected]>

system/jlib/jstats.cpp

@@ -794,35 +794,35 @@ static const constexpr StatisticMeta statsMetaData[StMax] = {
     { WHENFIRSTSTAT(WorkunitModified), UNUSED },
     { TIMESTAT(Elapsed), "The elapsed time between starting and finishing\nFor child queries this may be significantly larger than TimeTotalExecute" },
     { TIMESTAT(LocalExecute), "The time spent executing this activity not including its inputs\nSort activities by local execute time to help isolate potential processing bottlenecks" },
-    { TIMESTAT(TotalExecute), "The time spent executing this activity and its inputs.\nSort activities by total execute time to find sections of a query that are a bottleneck" },
+    { TIMESTAT(TotalExecute), "The time spent executing this activity and its inputs\nSort activities by total execute time to find sections of a query that are a bottleneck" },
     { TIMESTAT(Remaining), UNUSED },
     { SIZESTAT(GeneratedCpp), "The size of the generated c++ file" },
     { SIZESTAT(PeakMemory), "The peak memory used while processing this item" },
     { SIZESTAT(MaxRowSize), "The high water mark of the memory used for representing rows (roxiemem)" },
-    { NUMSTAT(RowsProcessed), "How many rows have been processed" },
+    { NUMSTAT(RowsProcessed), "The number of rows processed" },
     { NUMSTAT(Slaves), "The number of parallel execution processes used to execute an activity" },
-    { NUMSTAT(Starts), "How many times the activity has started executing\nAn activity is active if this does not match NumStops" },
-    { NUMSTAT(Stops), "How many times the activity has stopped executing.\nAn activity is active if this is less than NumStarts" },
-    { NUMSTAT(IndexSeeks), "The number of keyed lookups on an index.\nThese correspond to KEYED() filters on indexes.  A single keyed filter may result in multiple seeks if a leading component is not single-valued" },
-    { NUMSTAT(IndexScans), "The number of index scans.\nHow many entries are sequentially examined after an initial seek (including wild seeks).  Large numbers compared to the number of seeks may indicate extra keyed filters would be worthwhile" },
-    { NUMSTAT(IndexWildSeeks), "The number of seeks caused by WILD() filters.\nThe number of keyed lookups that had to search for the next potential match.  If this is a high proportion of NumIndexScans it may suggest poor key design" },
+    { NUMSTAT(Starts), "The number of times the activity has started executing\nAn activity is active if this does not match NumStops" },
+    { NUMSTAT(Stops), "The number of times the activity has stopped executing\nAn activity is active if this is less than NumStarts" },
+    { NUMSTAT(IndexSeeks), "The number of keyed lookups on an index\nThese correspond to KEYED() filters on indexes.  A single keyed filter may result in multiple seeks if a leading component is not single-valued" },
+    { NUMSTAT(IndexScans), "The number of index scans\nHow many entries are sequentially examined after an initial seek (including wild seeks).  Large numbers compared to the number of seeks may indicate extra keyed filters would be worthwhile" },
+    { NUMSTAT(IndexWildSeeks), "The number of seeks caused by WILD() filters\nThe number of keyed lookups that had to search for the next potential match.  If this is a high proportion of NumIndexScans it may suggest poor key design" },
     { NUMSTAT(IndexSkips), "The number of smart-stepping operations that increment the next match" },
-    { NUMSTAT(IndexNullSkips), "The number of smart-stepping operations that have no effect.\nIf this is large compare to NumIndexSkips it suggests the priority may not be set correctly" },
+    { NUMSTAT(IndexNullSkips), "The number of smart-stepping operations that had no effect\nIf this is large compare to NumIndexSkips it suggests the priority may not be set correctly" },
     { NUMSTAT(IndexMerges), "The number of merges set up when smart stepping"},
     { NUMSTAT(IndexMergeCompares), "The number of merge comparisons when smart stepping" },
     { NUMSTAT(PreFiltered), "The number of LEFT rows filtered before performing a keyed lookup" },
     { NUMSTAT(PostFiltered), "The number of index matches filtered by the transform and the non-keyed filter" },
-    { NUMSTAT(BlobCacheHits), "The number of times a blob is resolved in the cache" },
-    { NUMSTAT(LeafCacheHits), "The number of times a leaf node is resolved in the cache" },
-    { NUMSTAT(NodeCacheHits), "The number of times a branch node is resolved in the cache" },
+    { NUMSTAT(BlobCacheHits), "The number of times a blob was resolved in the cache" },
+    { NUMSTAT(LeafCacheHits), "The number of times a leaf node was resolved in the cache" },
+    { NUMSTAT(NodeCacheHits), "The number of times a branch node was resolved in the cache" },
     { NUMSTAT(BlobCacheAdds), "The number of times a blob was read from disk rather than the cache" },
-    { NUMSTAT(LeafCacheAdds), "The number of times a leaf node was read from disk rather than the cache.\nIf this number is high it may be worth experimenting with the leaf cache size (the branch cache size is more important)" },
-    { NUMSTAT(NodeCacheAdds), "The number of times a branch node was read from disk rather than the cache.\nBranch cache hits are significant for performance.  If this number is high it is likely to be worth increasing the node cache size.  If this number does not increase once the system is warmed up it may be worth reducing the cache size." },
+    { NUMSTAT(LeafCacheAdds), "The number of times a leaf node was read from disk rather than the cache\nIf this number is high it may be worth experimenting with the leaf cache size (the branch cache size is more important)" },
+    { NUMSTAT(NodeCacheAdds), "The number of times a branch node was read from disk rather than the cache\nBranch cache hits are significant for performance.  If this number is high it is likely to be worth increasing the node cache size.  If this number does not increase once the system is warmed up it may be worth reducing the cache size" },
     { NUMSTAT(PreloadCacheHits), UNUSED },
     { NUMSTAT(PreloadCacheAdds), UNUSED },
     { NUMSTAT(ServerCacheHits), UNUSED },
-    { NUMSTAT(IndexAccepted), "The number of keyed join matches that return a result from the transform" },
-    { NUMSTAT(IndexRejected), "The number of keyed join matches that are skipped by the transform" },
+    { NUMSTAT(IndexAccepted), "The number of KEYED JOIN matches that return a result from the TRANSFORM" },
+    { NUMSTAT(IndexRejected), "The number of KEYED JOIN matches that are skipped by the TRANSFORM" },
     { NUMSTAT(AtmostTriggered), "The number of times ATMOST on a JOIN causes it to fail to match" },
     { NUMSTAT(DiskSeeks), "The number of FETCHES from disk" },
     { NUMSTAT(Iterations), "The number of LOOP iterations executed" },
@@ -832,9 +832,9 @@ static const constexpr StatisticMeta statsMetaData[StMax] = {
     { PERSTAT(Replicated), "The percentage replication complete" },
     { NUMSTAT(DiskRowsRead), "The number of rows read from the file" },
     { NUMSTAT(IndexRowsRead), "The number of rows read from the index" },
-    { NUMSTAT(DiskAccepted), "The number of disk rows that resturn a result from the transform" },
-    { NUMSTAT(DiskRejected), "The number of disk rows that are skipped by the transform" },
-    { TIMESTAT(Soapcall), "Time taken to executing a SOAPCALL" },
+    { NUMSTAT(DiskAccepted), "The number of disk rows that return a result from the TRANSFORM" },
+    { NUMSTAT(DiskRejected), "The number of disk rows that are skipped by the TRANSFORM" },
+    { TIMESTAT(Soapcall), "The time taken to executing a SOAPCALL" },
     { TIMESTAT(FirstExecute), "The time taken to return the first row from this activity" },
     { TIMESTAT(DiskReadIO), "Total time spent reading from disk" },
     { TIMESTAT(DiskWriteIO), "Total time spent writing to disk" },
@@ -844,15 +844,15 @@ static const constexpr StatisticMeta statsMetaData[StMax] = {
     { CYCLESTAT(DiskWriteIO) },
     { NUMSTAT(DiskReads), "The number of disk read operations" },
     { NUMSTAT(DiskWrites), "The number of disk write operations" },
-    { NUMSTAT(Spills), "How many times the activity spilt to disk"},
+    { NUMSTAT(Spills), "The number of times the activity spilt to disk"},
     { TIMESTAT(SpillElapsed), "Time spent spilling rows from memory to disk" }, //MORE: Do we have a similar stat for SpillRead?
     { TIMESTAT(SortElapsed), "Time spent sorting rows in memory" },
     { NUMSTAT(Groups), "The number of groups processed by this activity" },
-    { NUMSTAT(GroupMax), "The size of the largest group processed by this activity.\nA skew in group size can cause a skew in processing time.  A large skew may indicate some special values would benefit from special casing." },
+    { NUMSTAT(GroupMax), "The size of the largest group processed by this activity\nA skew in group size can cause a skew in processing time.  A large skew may indicate some special values would benefit from special casing" },
     { SIZESTAT(SpillFile), "Total size of data spilled to disk" },
     { CYCLESTAT(SpillElapsed) },
     { CYCLESTAT(SortElapsed) },
-    { NUMSTAT(Strands), "The number of parallel execution strands.\n(A partially implemented feature to allow parallel execution within an activity)" },
+    { NUMSTAT(Strands), "The number of parallel execution strands\n(A partially implemented feature to allow parallel execution within an activity)" },
     { CYCLESTAT(TotalExecute) },
     { NUMSTAT(Executions), "The number of times a graph has been executed" },
     { TIMESTAT(TotalNested), UNUSED },
@@ -861,7 +861,7 @@ static const constexpr StatisticMeta statsMetaData[StMax] = {
     { NUMSTAT(ScansPerRow), UNUSED },
     { NUMSTAT(Allocations), "The number of allocations from the row memory" },
     { NUMSTAT(AllocationScans), "The number of scans within the memory manager when allocating row memory\nOnly applies to the scanning heap manager (not used by default)" },
-    { NUMSTAT(DiskRetries), "The number of times an io operation was retried.\nIf this is non zero it may suggest a problem with the underlying disk storage" },
+    { NUMSTAT(DiskRetries), "The number of times an I/O operation was retried\nIf this is non zero it may suggest a problem with the underlying disk storage" },
     { CYCLESTAT(Elapsed) },
     { CYCLESTAT(Remaining) },
     { CYCLESTAT(Soapcall) },
@@ -871,46 +871,46 @@ static const constexpr StatisticMeta statsMetaData[StMax] = {
     { CYCLESTAT(Generate) },
     { WHENFIRSTSTAT(Started), "Time when this activity or operation started" },
     { WHENLASTSTAT(Finished), "Time when this activity or operation finished" },
-    { NUMSTAT(AnalyseExprs), "Code generator internal.\nThe number of expressions that were processed by transformer::analyse()" },
-    { NUMSTAT(TransformExprs), "Code generator internal.\nThe number of expressions that were processed by transformer::transform()" },
-    { NUMSTAT(UniqueAnalyseExprs), "Code generator internal.\nThe number of unique expressions that were processed by transformer::analyse()" },
-    { NUMSTAT(UniqueTransformExprs), "Code generator internal.\nThe number of unique expressions that were processed by transformer::transform()" },
+    { NUMSTAT(AnalyseExprs), "Code generator internal\nThe number of expressions that were processed by transformer::analyse()" },
+    { NUMSTAT(TransformExprs), "Code generator internal\nThe number of expressions that were processed by transformer::transform()" },
+    { NUMSTAT(UniqueAnalyseExprs), "Code generator internal\nThe number of unique expressions that were processed by transformer::analyse()" },
+    { NUMSTAT(UniqueTransformExprs), "Code generator internal\nThe number of unique expressions that were processed by transformer::transform()" },
     { NUMSTAT(DuplicateKeys), "The number of duplicate keys that were present in the index" },
     { NUMSTAT(AttribsProcessed), "The number of attributes processed when parsing the ECL" },
     { NUMSTAT(AttribsSimplified), UNUSED },
     { NUMSTAT(AttribsFromCache), UNUSED },
-    { NUMSTAT(SmartJoinDegradedToLocal), "The number of times a global smart-join switched to a LOCAL JOIN (with distribute)" },
+    { NUMSTAT(SmartJoinDegradedToLocal), "The number of times a global smart-join switched to a LOCAL JOIN (with distribute)\nThis will be 0 or 1 unless the activity is within a LOOP" },
     { NUMSTAT(SmartJoinSlavesDegradedToStd), "The number of times a global smart-join degraded to a standard join" },
     { NUMSTAT(AttribsSimplifiedTooComplex), UNUSED },
     { NUMSTAT(SysContextSwitches), "The number of context switches that occurred when processing" },
     { TIMESTAT(OsUser), "Total elapsed user-space time" },
     { TIMESTAT(OsSystem), "Total time spent in the system/kernel" },
-    { TIMESTAT(OsTotal), "Total elapsed time according to the OS.\nIncludes system,user,idle and iowait times" },
+    { TIMESTAT(OsTotal), "Total elapsed time according to the OS\nIncludes system, user, idle and iowait times" },
     { CYCLESTAT(OsUser) },
     { CYCLESTAT(OsSystem) },
     { CYCLESTAT(OsTotal) },
     //The following seem to be duplicates of the values above
     { NUMSTAT(ContextSwitches), "The number of context switches that occurred when processing" },
     { TIMESTAT(User), "Total elapsed user-space time" },
     { TIMESTAT(System), "Total time spent in the system/kernel" },
-    { TIMESTAT(Total), "Total elapsed time according to the OS.\nInclude system,user,idle and iowait times." },
+    { TIMESTAT(Total), "Total elapsed time according to the OS\nInclude system,user,idle and iowait times" },
     { CYCLESTAT(User) },
     { CYCLESTAT(System) },
     { CYCLESTAT(Total) },
     { SIZESTAT(OsDiskRead), UNUSED },
     { SIZESTAT(OsDiskWrite), UNUSED },
     { TIMESTAT(Blocked), "Time spent blocked waiting for another operation to complete" },
     { CYCLESTAT(Blocked) },
-    { COSTSTAT(Execute), "Cpu cost of executing" },
+    { COSTSTAT(Execute), "The CPU cost of executing" },
     { SIZESTAT(AgentReply), "Size of data sent from the workers to the agent" },
-    { TIMESTAT(AgentWait), "Time that the agent spends waiting for a reply from the workers" },
+    { TIMESTAT(AgentWait), "Time that the agent spent waiting for a reply from the workers" },
     { CYCLESTAT(AgentWait) },
     { COSTSTAT(FileAccess), "The transactional cost of any file operations" },
-    { NUMSTAT(Pods), "How many pods were used" },
+    { NUMSTAT(Pods), "The number of pods used" },
     { COSTSTAT(Compile), "The cost to compile this workunit"},
     { TIMESTAT(NodeLoad), "Time spent reading branch nodes from disk and decompressing them" },
     { CYCLESTAT(NodeLoad) },
-    { TIMESTAT(LeafLoad), "Time spent reading leaf nodes from disk and decompressing them\nIf this is a high proportion of the time (especially compared to TimeLeadRead) then consider using the new index compression formats" },
+    { TIMESTAT(LeafLoad), "Time spent reading leaf nodes from disk and decompressing them\nIf this is a high proportion of the time (especially compared to TimeLeafRead) then consider using the new index compression formats" },
     { CYCLESTAT(LeafLoad) },
     { TIMESTAT(BlobLoad), "Time spent reading blob nodes from disk and decompressing them" },
     { CYCLESTAT(BlobLoad) },
@@ -928,22 +928,22 @@ static const constexpr StatisticMeta statsMetaData[StMax] = {
     { NUMSTAT(NodeDiskFetches), "Number of times a branch node was read from disk rather than the linux page cache" },
     { NUMSTAT(LeafDiskFetches), "Number of times a leaf node was read from disk rather than the linux page cache\nIf this is a significant proportion of NumLeafAdds then consider allocating more memory, or reducing the leaf cache size" },
     { NUMSTAT(BlobDiskFetches), "Number of times a blob was read from disk rather than the linux page cache" },
-    { TIMESTAT(NodeFetch), "Time spent reading branch nodes from disk EXCLUDING the linux page cache)" },
+    { TIMESTAT(NodeFetch), "Time spent reading branch nodes from disk (EXCLUDING the linux page cache)" },
     { CYCLESTAT(NodeFetch) },
-    { TIMESTAT(LeafFetch), "Time spent reading leaf nodes from disk EXCLUDING the linux page cache)" },
+    { TIMESTAT(LeafFetch), "Time spent reading leaf nodes from disk (EXCLUDING the linux page cache)" },
     { CYCLESTAT(LeafFetch) },
-    { TIMESTAT(BlobFetch), "Time spent reading blobs from disk EXCLUDING the linux page cache)" },
+    { TIMESTAT(BlobFetch), "Time spent reading blobs from disk (EXCLUDING the linux page cache)" },
     { CYCLESTAT(BlobFetch) },
     { PEAKSIZESTAT(GraphSpill), "Peak size of spill memory usage" },
     { TIMESTAT(AgentQueue), "Time worker items were received and queued before being processed\nThis may indicate that the primary node on a channel was down, or that the workers are overloaded with requests" },
     { CYCLESTAT(AgentQueue) },
-    { TIMESTAT(IBYTIDelay), "Time spend waiting for another worker to start processing a request\nA non-zero value indicates that the primary node on a channel was down or very busy" },
+    { TIMESTAT(IBYTIDelay), "Time spent waiting for another worker to start processing a request\nA non-zero value indicates that the primary node on a channel was down or very busy" },
     { CYCLESTAT(IBYTIDelay) },
     { WHENFIRSTSTAT(Queued), "The time when this item was added to a queue" },
     { WHENFIRSTSTAT(Dequeued), "The time when this item was removed from a queue" },
-    { WHENFIRSTSTAT(K8sLaunched), "The time when the job to procss this item was launched" },
-    { WHENFIRSTSTAT(K8sStarted), "The time when the job to procss this item started executing/nThe difference between the K8sStarted and K8sLaunched indicates how long Kubernetes took to resource and initialised the job." },
-    { WHENFIRSTSTAT(K8sReady), "The time when the Thor job is ready to process\nThe difference with K8sStarted inidcates how long it took to resource and start the slave processes" },
+    { WHENFIRSTSTAT(K8sLaunched), "The time when the K8s job to process this item was launched" },
+    { WHENFIRSTSTAT(K8sStarted), "The time when the K8s job to process this item started executing/nThe difference between the K8sStarted and K8sLaunched indicates how long Kubernetes took to resource and initialised the job" },
+    { WHENFIRSTSTAT(K8sReady), "The time when the Thor job is ready to process\nThe difference with K8sStarted indicates how long it took to resource and start the slave processes" },
     { NUMSTAT(SocketWrites), "The number of writes to the client socket" },
     { SIZESTAT(SocketWrite), "The size of data written to the client socket" },
     { TIMESTAT(SocketWriteIO), "The total time spent writing data to the client socket" },
@@ -956,13 +956,13 @@ static const constexpr StatisticMeta statsMetaData[StMax] = {
     { SIZESTAT(RowMemory), "The size of memory used to store rows" },
     { SIZESTAT(PeakRowMemory), "The peak memory used to store rows" },
     { SIZESTAT(AgentSend), "The size of data sent to the agent from the server" },
-    { TIMESTAT(IndexCacheBlocked), "The time spend waiting to access the index page cache" },
+    { TIMESTAT(IndexCacheBlocked), "The time spent waiting to access the index page cache" },
     { CYCLESTAT(IndexCacheBlocked) },
-    { TIMESTAT(AgentProcess), "The total time spend by the agents processing requests" },
+    { TIMESTAT(AgentProcess), "The total time spent by the agents processing requests" },
     { CYCLESTAT(AgentProcess) },
-    { NUMSTAT(AckRetries), "How many times the server fails to receive a response from an agent within the expected time" },
+    { NUMSTAT(AckRetries), "The number of times the server failed to receive a response from an agent within the expected time" },
     { SIZESTAT(ContinuationData), "The total size of continuation data sent from agent to the server\nA large number may indicate a poor filter, or merging from many different index locations" },
-    { NUMSTAT(ContinuationRequests), "The number of time the agent indicated there was more data to be returned" },
+    { NUMSTAT(ContinuationRequests), "The number of times the agent indicated there was more data to be returned" },
 };
 
 static MapStringTo<StatisticKind, StatisticKind> statisticNameMap(true);