HPCC-26911 Lots of Roxie options are not listed in Helm schema

Remove options from XSD that are no longer active.
Rationalize a few (new) option names
Delete some unused options
Rename options that have different meaning from previous versions.
Add options that are still active to schema

Signed-off-by: Richard Chapman <rchapman@hpccsystems.com>

helm/hpcc/values.schema.json

@@ -1211,6 +1211,583 @@
         "certificate": {
           "type": "string",
           "description": "Name of the secret which contains the TLS certificate.  Custom configuration instead of using, or overriding cert-manager certificate."
+        },
+        
+        "allFilesDynamic": { 
+          "type": "boolean",
+          "default": false,
+          "description": "If enabled, files will be resolved per-query and not locked between queries"
+        },
+        "backgroundCopyClass": { 
+          "type": "string",
+          "default": "none",
+          "enum": [ "none", "best-effort", "idle"],
+          "description": "Specify an IONICE class for the background copy thread."
+        },
+        "backgroundCopyPrio": { 
+          "type": "integer",
+          "default": 0,
+          "description": "Specify an IONICE value for the background copy thread, if backgroundCopyClass set to best-effort."
+        },
+        "callbackRetries": { 
+          "type": "integer",
+          "default": 3,
+          "minimum": 1,
+          "description": "Number of retries before callbacks from agents to server are aborted"
+        },
+        "callbackTimeout": { 
+          "type": "integer",
+          "default": 5000,
+          "minimum": 0,
+          "description": "Timeout (in ms) before callbacks from agents to server are resent"
+        },
+        "checkFileDate": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Compare file dates of physical files with the information in DFS."
+        },
+        "collectFactoryStatistics": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Accumulate summary statistics for all queries"
+        },
+        "copyResources": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Copies any missing data files/keys from the position they were in when query was deployed."
+        },
+        "defaultHighPriorityTimeLimit": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Maximum run time (in ms) for any single active high-priority query (if not overridden)"
+        },
+        "defaultHighPriorityTimeWarning": { 
+          "type": "integer",
+          "default": 5000,
+          "minimum": 0,
+          "description": "Time (in ms) before generating SNMP warning for a high-priority query (if not overridden)"
+        },
+        "defaultLowPriorityTimeLimit": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Maximum run time (in ms) for any single active low-priority query (if not overridden)"
+        },
+        "defaultLowPriorityTimeWarning": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Time (in ms) before generating SNMP warning for a low-priority query (if not overridden)"
+        },
+        "defaultMemoryLimit": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Maximum amount of memory available for row data in any single active query (if not overridden)"
+        },
+        "defaultSLAPriorityTimeLimit": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Maximum run time (in ms) for any single active SLA-high-priority query (if not overridden)"
+        },
+        "defaultSLAPriorityTimeWarning": { 
+          "type": "integer",
+          "default": 5000,
+          "minimum": 0,
+          "description": "Time (in ms) before generating SNMP warning for a SLA-high-priority query (if not overridden)"
+        },
+        "defaultStripLeadingWhitespace": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Default value for stripping leading whitespace in input XML values"
+        },
+        "encryptionInTransit": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Encrypt traffic between Roxie nodes."
+        },
+        "flushJHtreeCacheOnOOM": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Should the index node memory allocation flush the cache and retry if memory allocation fails"
+        },
+        "fieldTranslationEnabled": {
+          "default": "payload",
+          "enum": ["false", "true", "payload"],
+          "description": "Enables translation (where possible) of mismatched file layouts on-the-fly. Specify 'payload' to attempt to translate payload fields only"
+        },
+        "highTimeout": { 
+          "type": "integer",
+          "default": 2000,
+          "minimum": 0,
+          "description": "Timeout (in ms) before high priority requests are resent to agents"
+        },
+        "httpCallerIdHeader": { 
+          "type": "string",
+          "default": "HPCC-Caller-Id",
+          "description": "HTTP Header field to use for sending and receiving CallerId"
+        },
+        "httpGlobalIdHeader": { 
+          "type": "string",
+          "default": "HPCC-Global-Id",
+          "description": "HTTP Header field to use for sending and receiving GlobalId"
+        },
+        "ignoreOrphans": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Treat out-of-date local files as if they were not present."
+        },
+        "lazyOpen": {
+          "type": "boolean",
+          "default": false,
+          "description": "Delay opening files until first use."
+        },
+        "localFilesExpire": { 
+          "type": "integer",
+          "default": -1,
+          "description": "Period (in ms) of inactivity before a local datafile handle is closed"
+        },
+        "lockSuperFiles": { 
+          "type": "boolean",
+          "default": false,
+          "description": "If enabled, superfiles will be locked while queries that use them are loaded"
+        },
+        "lowTimeout": { 
+          "type": "integer",
+          "default": 10000,
+          "minimum": 0,
+          "description": "Timeout (in ms) before low priority requests are resent to agents"
+        },
+        "maxHttpConnectionRequests": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Max number of query requests per persistent http connection"
+        },
+        "maxHttpKeepAliveWait": { 
+          "type": "integer",
+          "default": 5000,
+          "minimum": 0,
+          "description": "Max number of miliseconds to wait for additional requests on a persistent http connection"
+        },
+        "maxLocalFilesOpen": { 
+          "type": "integer",
+          "default": 4000,
+          "minimum": 0,
+          "description": "Maximum number of local files to keep open"
+        },
+        "maxRemoteFilesOpen": { 
+          "type": "integer",
+          "default": 1000,
+          "minimum": 0,
+          "description": "Maximum number of remote files to keep open"
+        },
+        "minLocalFilesOpen": { 
+          "type": "integer",
+          "default": 2000,
+          "minimum": 0,
+          "description": "Minimum number of local files to keep open"
+        },
+        "minRemoteFilesOpen": { 
+          "type": "integer",
+          "default": 500,
+          "minimum": 0,
+          "description": "Minimum number of remote files to keep open"
+        },
+        "parallelQueryLoadThreads": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Use up to n multiple threads for initial query loading"
+        },
+        "preloadOnceData": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Evaluate : ONCE sections of queries at query load time"
+        },
+        "prestartAgentThreads": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Prestart agent worker threads at startup"
+        },
+        "reloadRetriesSuspended": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Retry loading of suspended queries whenever QuerySet reloads"
+        },
+        "remoteFilesExpire": { 
+          "type": "integer",
+          "default": 3600000,
+          "minimum": 0,
+          "description": "Period (in ms) of inactivity before a remote datafile handle is closed"
+        },
+        "serverThreads": { 
+          "type": "integer",
+          "default": 30,
+          "minimum": 0,
+          "description": "Default number of threads processing Roxie server requests (if not specified on service)"
+        },
+        "slaTimeout": { 
+          "type": "integer",
+          "default": 2000,
+          "minimum": 0,
+          "description": "Timeout (in ms) before SLA high priority requests are resent to agents"
+        },
+        "agentQueryReleaseDelaySeconds": { 
+          "type": "integer",
+          "default": 60,
+          "minimum": 0,
+          "description": "Delay before unregistering slave queries to allow in-flight to complete. Files are locked until query is unregistered."
+        },
+        "agentThreads": { 
+          "type": "integer",
+          "default": 30,
+          "minimum": 0,
+          "description": "Number of threads processing agent requests"
+        },
+        "statsExpiryTime": { 
+          "type": "integer",
+          "default": 3600,
+          "minimum": 0,
+          "description": "Time (in seconds) that detailed reporting stats are kept"
+        },
+        "totalMemoryLimit": { 
+          "type": "integer",
+          "default": 1073741824,
+          "minimum": 0,
+          "description": "Maximum amount of memory available for row data in all active queries"
+        },
+        "heapUseHugePages": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Allow roxie to use memory from huge pages if they have been configured."
+        },
+        "heapUseTransparentHugePages": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Allow roxie to use memory from transparent huge pages."
+        },
+        "heapRetainMemory": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Retain and do not return unused memory to the operating system."
+        },
+        "trapTooManyActiveQueries": { 
+          "type": "boolean",
+          "default": true,
+          "description": "should an SNMP trap get sent when too many active query error occurs"
+        },
+        "useMemoryMappedIndexes": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Using memory-mapped files when merging multiple result streams from row-compressed indexes."
+        },
+        "useRemoteResources": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Reads any missing data files/keys from the position they were in when deployed."
+        },
+        "traceLevel": { 
+          "type": "integer",
+          "default": 1,
+          "minimum": 0,
+          "description": "Level of detail in reporting (set to 0 for none, 1 for normal, > 1 or more for extended)"
+        },
+        "logFullQueries": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Log full text (unless blindLogging) and resource usage of all queries received "
+        },
+        "blindLogging": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Suppress all logging of any data or query text"
+        },
+        "memTraceLevel": { 
+          "type": "integer",
+          "default": 1,
+          "minimum": 0,
+          "description": "Level of detail in reporting mem mgr information(set to 0 for none, 1 for normal, >1 or more for extended)"
+        },
+        "miscDebugTraceLevel": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Level of miscellaneous debug tracing unrelated to all other tracing(set to 0 for none, 1 for normal, >1 or more for extended)"
+        },
+        "soapTraceLevel": { 
+          "type": "integer",
+          "default": 1,
+          "minimum": 0,
+          "description": "Level of detail in reporting SOAPCALL information(set to 0 for none, 1 for normal, >1 or more for extended)"
+        },
+        "traceTranslations": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Trace record layout translations to log file"
+        },
+        "traceEnabled": { 
+          "type": "boolean",
+          "default": false,
+          "description": "TRACE activity output enabled by default (can be overridden in workunit or query)"
+        },
+        "traceLimit": { 
+          "type": "integer",
+          "default": 10,
+          "minimum": 0,
+          "description": "Number of rows output by TRACE activity"
+        },
+        "udpTraceLevel": { 
+          "type": "integer",
+          "default": 1,
+          "minimum": 0,
+          "description": "Level of detail in reporting udp information(set to 0 for none, 1 for normal, >1 or more for extended)"
+        },
+        "udpAdjustThreadPriorities": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Should UDP socket reading threads operate at elevated priority"
+        },
+        "udpFlowSocketsSize": { 
+          "type": "integer",
+          "default": 131072,
+          "minimum": 0,
+          "description": "Controls the read socket buffer size of the UDP layer flow control sockets"
+        },
+        "udpLocalWriteSocketSize": { 
+          "type": "integer",
+          "default": 1024000,
+          "minimum": 0,
+          "description": "Controls the write socket buffer size of the local UDP sockets (Agent to Server on same node)"
+        },
+        "udpAgentBufferSize": { 
+          "type": "integer",
+          "default": 262142,
+          "minimum": 0,
+          "description": "Controls the read socket buffer size of the UDP agent read sockets"
+        },
+        "udpOutQsPriority": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Turns on/off Priority weight-based for output queues (0 round-robin no priority - old logic, 1 round-robin new logic, 2 and higher is factor of priority)"
+        },
+        "udpQueueSize": { 
+          "type": "integer",
+          "default": 100,
+          "minimum": 0,
+          "description": "UDP transport layer receive queue size"
+        },
+        "udpResendLostPackets": { 
+          "type": "boolean",
+          "default": true,
+          "description": "UDP transport layer resend lost packets"
+        },
+        "udpSendQueueSize": { 
+          "type": "integer",
+          "default": 50,
+          "minimum": 0,
+          "description": "UDP transport layer send queue size"
+        },
+        "udpStatsReportInterval": { 
+          "type": "integer",
+          "default": 60000,
+          "minimum": 0,
+          "description": "UDP transport layer stats reporting interval"
+        },
+        "blobCacheMem": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Size (in Mb) of blob index page cache"
+        },
+        "leafCacheMem": { 
+          "type": "integer",
+          "default": 50,
+          "minimum": 0,
+          "description": "Size (in Mb) of leaf index page cache"
+        },
+        "nodeCacheMem": { 
+          "type": "integer",
+          "default": 100,
+          "minimum": 0,
+          "description": "Size (in Mb) of non-leaf index page cache"
+        },
+        "mysqlCacheCheckPeriod": { 
+          "type": "integer",
+          "default": 10000,
+          "minimum": 0,
+          "description": "Time to wait (ms) between checking if any cached MySQL connections can be closed"
+        },
+        "mysqlCacheTimeoutPeriod": { 
+          "type": "integer",
+          "default": 60000,
+          "minimum": 0,
+          "description": "Time to wait (ms) before closing a cached MySQL connection"
+        },
+        "mysqlConnectionCacheSize": { 
+          "type": "integer",
+          "default": 10000,
+          "minimum": 0,
+          "description": "Number of MySQL connections to hold in cache"
+        },
+        "checkCompleted": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Check pending replies when agent gets a retry request"
+        },
+        "dafilesrvLookupTimeout": { 
+          "type": "integer",
+          "default": 10000,
+          "minimum": 0,
+          "description": "Maximum time (in milliseconds) dafilesrv will wait before timing out the first time through the list"
+        },
+        "defaultConcatPreload": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Default concat preload"
+        },
+        "defaultFetchPreload": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Default fetch preload"
+        },
+        "defaultFullKeyedJoinPreload": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Default full keyed join preload"
+        },
+        "defaultKeyedJoinPreload": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Default keyed join preload"
+        },
+        "defaultParallelJoinPreload": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Default parallel join preload"
+        },
+        "defaultPrefetchProjectPreload": { 
+          "type": "integer",
+          "default": 10,
+          "minimum": 0,
+          "description": "Default prefetch value for PROJECT,PREFETCH activity"
+        },
+        "doIbytiDelay": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Enables the IBYTI delay logic in the agents."
+        },
+        "enableHeartBeat": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Enable HeartBeat messages to roxiepipe clients"
+        },
+        "fastLaneQueue": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Enable special fast-lane queue for simple queries."
+        },
+        "ignoreMissingFiles": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Ignore missing files"
+        },
+        "indexReadChunkSize": { 
+          "type": "integer",
+          "default": 60000,
+          "minimum": 0,
+          "description": "Break up results from indexRead (and other remote activities) every N bytes"
+        },
+        "initIbytiDelay": { 
+          "type": "integer",
+          "default": 50,
+          "minimum": 0,
+          "description": "Initial time (in milliseconds) a secondary agent will wait for an IBYTI packet from a primary peer."
+        },
+        "mtuPayload": { 
+          "type": "integer",
+          "default": 1400,
+          "minimum": 1400,
+          "maximum": 9000,
+          "description": "Set higher than 1400 for networks with a larger MTU."
+        },
+        "linuxYield": { 
+          "type": "boolean",
+          "default": false,
+          "description": "Yield to scheduler in some tight loops. May help latency on uniprocessor machines"
+        },
+        "maxBlockSize": { 
+          "type": "integer",
+          "default": 10000000,
+          "minimum": 0,
+          "description": "Max size of block read from client socket"
+        },
+        "maxLockAttempts": { 
+          "type": "integer",
+          "default": 5,
+          "minimum": 0,
+          "description": "Number of retries to get lock for global queries"
+        },
+        "memoryStatsInterval": { 
+          "type": "integer",
+          "default": 60,
+          "minimum": 0,
+          "description": "Interval (in seconds) between reports on Roxie heap usage"
+        },
+        "memTraceSizeLimit": { 
+          "type": "integer",
+          "default": 10,
+          "minimum": 0,
+          "description": "Generate stacktrace whenever a request is made for a row larger than this threshold (0 to disable)"
+        },
+        "parallelAggregate": { 
+          "type": "integer",
+          "default": 0,
+          "minimum": 0,
+          "description": "Number of parallel threads to use for in-memory aggregate processing. Set to 0 to use one per CPU, 1 to disable parallel processing of in-memory aggregates"
+        },
+        "perChannelFlowLimit": { 
+          "type": "integer",
+          "default": 10,
+          "minimum": 1,
+          "description": "Number of pending queries permitted per channel (per active activity) before blocking"
+        },
+        "pingInterval": { 
+          "type": "integer",
+          "default": 60,
+          "minimum" : 0,
+          "description": "Interval (in seconds) between Roxie server ping tests"
+        },
+        "preabortIndexReadsThreshold": { 
+          "type": "integer",
+          "default": 100,
+          "minimum": 0,
+          "description": "Use seek to precheck keyed limits (i.e. assume ,COUNT) on index reads if limit greater than this value"
+        },
+        "preabortKeyedJoinsThreshold": { 
+          "type": "integer",
+          "minimum" : 0,
+          "default": 100,
+          "description": "Use seek to precheck limits on keyed joins if limit greater than this value"
+        },
+        "simpleLocalKeyedJoins": { 
+          "type": "boolean",
+          "default": true,
+          "description": "Enable single-threaded local keyed joins"
+        },
+        "socketCheckInterval": { 
+          "type": "integer",
+          "default": 5000,
+          "minimum": 0,
+          "description": "Interval (in milliseconds) between checks that client socket is still open"
         }
       }
     },

initfiles/componentfiles/configschema/xsd/roxie.xsd

@@ -407,9 +407,6 @@
                     <xs:attribute name="defaultPrefetchProjectPreload" type="xs:nonNegativeInteger"
                                   hpcc:displayName="Default Prefetch Project Preload" hpcc:presetValue="10"
                                   hpcc:tooltip="Default prefetch value for PROJECT,PREFETCH activity"/>
-                    <xs:attribute name="diskReadBufferSize" type="xs:nonNegativeInteger"
-                                  hpcc:displayName="Disk Read Buffer Size (bytes)" hpcc:presetValue="65536"
-                                  hpcc:tooltip="Default buffer size for disk read operations"/>
                     <xs:attribute name="doIbytiDelay" type="xs:boolean" hpcc:displayName="Enable IBYTI Ddelay Logic"
                                   hpcc:presetValue="true" hpcc:tooltip="Enables the IBYTI delay logic in the agents"/>
                     <xs:attribute name="enableHeartBeat" type="xs:boolean" hpcc:displayName="Enable Heartbeat"

initfiles/componentfiles/configxml/roxie.xsd.in

@@ -617,13 +617,6 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="enableKeyDiff" type="xs:boolean" use="optional" default="true">
-      <xs:annotation>
-        <xs:appinfo>
-          <tooltip>Enable / Disable key diff functionality in roxie.</tooltip>
-        </xs:appinfo>
-      </xs:annotation>
-    </xs:attribute>
     <xs:attribute name="enableSysLog" type="xs:boolean" use="optional" default="true">
         <xs:annotation>
             <xs:appinfo>
@@ -631,6 +624,13 @@
             </xs:appinfo>
         </xs:annotation>
     </xs:attribute>
+    <xs:attribute name="encryptionInTransit" type="xs:boolean" use="optional" default="false">
+        <xs:annotation>
+            <xs:appinfo>
+                <tooltip>Encrypt traffic between Roxie nodes.</tooltip>
+            </xs:appinfo>
+        </xs:annotation>
+    </xs:attribute>
     <xs:attribute name="flushJHtreeCacheOnOOM" type="xs:boolean" use="optional" default="true">
       <xs:annotation>
         <xs:appinfo>
@@ -781,6 +781,13 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
+    <xs:attribute name="parallelQueryLoadThreads" type="nonNegativeInteger" use="optional" default="0">
+      <xs:annotation>
+        <xs:appinfo>
+          <tooltip>Use up to n multiple threads for initial query loading</tooltip>
+        </xs:appinfo>
+      </xs:annotation>
+    </xs:attribute>
     <xs:attribute name="preferredSubnet" type="xs:string" use="optional" default="">
       <xs:annotation>
         <xs:appinfo>
@@ -809,10 +816,10 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="reloadRetriesFailed" type="xs:boolean" use="optional" default="true">
+    <xs:attribute name="reloadRetriesSuspended" type="xs:boolean" use="optional" default="true">
       <xs:annotation>
         <xs:appinfo>
-          <tooltip>Retry loading of failed queries whenever QuerySet reloads</tooltip>
+          <tooltip>Retry loading of suspended queries whenever QuerySet reloads</tooltip>
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
@@ -1069,35 +1076,28 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="udpFlowSocketsSize" type="xs:nonNegativeInteger" use="optional" default="131071">
-      <xs:annotation>
-        <xs:appinfo>
-          <tooltip>Controls the read socket buffer size of the UDP layer flow control sockets</tooltip>
-        </xs:appinfo>
-      </xs:annotation>
-    </xs:attribute>
-    <xs:attribute name="udpLocalWriteSocketSize" type="xs:nonNegativeInteger" use="optional" default="131071">
+    <xs:attribute name="udpAdjustThreadPriorities" type="xs:boolean" use="optional" default="false">
       <xs:annotation>
         <xs:appinfo>
-          <tooltip>Controls the write socket buffer size of the local UDP sockets (Agent to Server on same node)</tooltip>
+          <tooltip>Should UDP socket reading threads operate at elevated priority</tooltip>
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="udpMaxRetryTimedoutReqs" type="xs:nonNegativeInteger" use="optional" default="0">
+    <xs:attribute name="udpFlowSocketsSize" type="xs:nonNegativeInteger" use="optional" default="131071">
       <xs:annotation>
         <xs:appinfo>
-          <tooltip>Controls the Max number of agent "request to send" or "permission to send" to be retried. 0 means keep retrying forever</tooltip>
+          <tooltip>Controls the read socket buffer size of the UDP layer flow control sockets</tooltip>
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="udpMaxSlotsPerClient" type="xs:nonNegativeInteger" use="optional" default="2147483647">
+    <xs:attribute name="udpLocalWriteSocketSize" type="xs:nonNegativeInteger" use="optional" default="1024000">
       <xs:annotation>
         <xs:appinfo>
-          <tooltip>UDP transport layer slots per client</tooltip>
+          <tooltip>Controls the write socket buffer size of the local UDP sockets (Agent to Server on same node)</tooltip>
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="udpMulticastBufferSize" type="xs:nonNegativeInteger" use="optional" default="131071">
+    <xs:attribute name="udpMulticastBufferSize" type="xs:nonNegativeInteger" use="optional" default="262142">
       <xs:annotation>
         <xs:appinfo>
           <tooltip>Controls the read socket buffer size of the UDP multicast sockets</tooltip>
@@ -1118,13 +1118,6 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="udpRequestToSendTimeout" type="xs:nonNegativeInteger" use="optional" default="0">
-        <xs:annotation>
-            <xs:appinfo>
-                <tooltip>Controls the timeout value agent udp will wait for permission to send from a Roxie server, in milliseconds. Specify 0 to calcuate automatically.</tooltip>
-            </xs:appinfo>
-        </xs:annotation>
-    </xs:attribute>
     <xs:attribute name="udpResendLostPackets" type="xs:boolean" use="optional" default="true">
       <xs:annotation>
         <xs:appinfo>
@@ -1132,13 +1125,6 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="udpResendTimeout" type="xs:nonNegativeInteger" use="optional" default="10">
-      <xs:annotation>
-        <xs:appinfo>
-          <tooltip>Time in milliseconds to assume a packet is in transit before assuming lost</tooltip>
-        </xs:appinfo>
-      </xs:annotation>
-    </xs:attribute>
     <xs:attribute name="udpSendQueueSize" type="xs:nonNegativeInteger" use="optional" default="50">
       <xs:annotation>
         <xs:appinfo>
@@ -1169,13 +1155,6 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="nodeCachePreload" type="xs:boolean" use="optional" default="false">
-      <xs:annotation>
-        <xs:appinfo>
-          <tooltip>Prefill the node cache with all non-leaf pages from all indexes</tooltip>
-        </xs:appinfo>
-      </xs:annotation>
-    </xs:attribute>
     <xs:attribute name="nodeCacheMem" type="xs:nonNegativeInteger" use="optional" default="100">
       <xs:annotation>
         <xs:appinfo>
@@ -1278,13 +1257,6 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="snifferPort" type="xs:nonNegativeInteger" use="optional" default="9003">
-      <xs:annotation>
-        <xs:appinfo>
-          <tooltip>Port used for UDP (slave->server) sniffer</tooltip>
-        </xs:appinfo>
-      </xs:annotation>
-    </xs:attribute>
   </xs:attributeGroup>
   <xs:attributeGroup name="Debug">
     <xs:attribute name="alwaysFailOnLeaks" type="xs:boolean" use="optional" default="false">
@@ -1350,14 +1322,7 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-      <xs:attribute name="diskReadBufferSize" type="xs:nonNegativeInteger" use="optional" default="65536">
-          <xs:annotation>
-              <xs:appinfo>
-                  <tooltip>Default buffer size for disk read operations</tooltip>
-              </xs:appinfo>
-          </xs:annotation>
-      </xs:attribute>
-      <xs:attribute name="doIbytiDelay" type="xs:boolean" use="optional" default="true">
+    <xs:attribute name="doIbytiDelay" type="xs:boolean" use="optional" default="true">
       <xs:annotation>
         <xs:appinfo>
           <tooltip>Enables the IBYTI delay logic in the agents.</tooltip>
@@ -1399,7 +1364,7 @@
         </xs:appinfo>
       </xs:annotation>
     </xs:attribute>
-    <xs:attribute name="initIbytiDelay" type="xs:nonNegativeInteger" use="optional" default="100">
+    <xs:attribute name="initIbytiDelay" type="xs:nonNegativeInteger" use="optional" default="50">
       <xs:annotation>
         <xs:appinfo>
           <tooltip>Initial time (in milliseconds) a secondary agent will wait for an IBYTI packet from a primary peer.</tooltip>

initfiles/etc/DIR_NAME/environment.xml.in

@@ -60,7 +60,6 @@
                 defaultStripLeadingWhitespace="1"
                 description="Roxie cluster"
                 directory="${RUNTIME_PATH}/myroxie"
-                diskReadBufferSize="65536"
                 doIbytiDelay="true"
                 enableHeartBeat="true"
                 enableKeyDiff="true"

roxie/ccd/ccd.hpp

@@ -372,7 +372,7 @@ extern bool enableKeyDiff;
 extern PTreeReaderOptions defaultXmlReadFlags;
 extern bool mergeAgentStatistics;
 extern bool defaultNoSeekBuildIndex;
-extern unsigned parallelLoadQueries;
+extern unsigned parallelQueryLoadThreads;
 extern bool adhocRoxie;
 extern bool alwaysFailOnLeaks;
 extern SinkMode defaultSinkMode;
@@ -397,7 +397,6 @@ extern IPropertyTree *roxiePortTlsClientConfig;
 
 
 extern unsigned udpMulticastBufferSize;
-extern size32_t diskReadBufferSize;
 
 extern unsigned nodeCacheMB;
 extern unsigned leafCacheMB;

roxie/ccd/ccdactivities.cpp

@@ -45,8 +45,6 @@
 #include "thorstrand.hpp"
 #include "jstats.h"
 
-size32_t diskReadBufferSize = 0x10000;
-
 using roxiemem::OwnedRoxieRow;
 using roxiemem::OwnedConstRoxieRow;
 using roxiemem::OwnedRoxieString;

roxie/ccd/ccdmain.cpp

@@ -74,9 +74,9 @@ unsigned parallelLoopFlowLimit = 100;
 unsigned perChannelFlowLimit = 10;
 time_t startupTime;
 unsigned statsExpiryTime = 3600;
-unsigned miscDebugTraceLevel = 0;  // separate trace settings purely for debugging specific items (i.e. all possible locations to look for files at startup)
+unsigned miscDebugTraceLevel = 0;      // separate trace settings purely for debugging specific items (i.e. all possible locations to look for files at startup)
 bool traceRemoteFiles = false;
-unsigned readTimeout = 300;
+unsigned readTimeout = 300;            // timeout (in ms) for reading input data blocks in roxiepipe mode
 unsigned indexReadChunkSize = 60000;
 unsigned maxBlockSize = 10000000;
 unsigned maxLockAttempts = 5;
@@ -125,7 +125,6 @@ bool useAeron;
 bool ignoreOrphans;
 bool doIbytiDelay = true; 
 bool copyResources;
-bool enableKeyDiff = true;
 bool chunkingHeap = true;
 bool logFullQueries;
 bool blindLogging = false;
@@ -138,7 +137,7 @@ bool reloadRetriesFailed;
 bool selfTestMode = false;
 bool defaultCollectFactoryStatistics = true;
 bool defaultNoSeekBuildIndex = false;
-unsigned parallelLoadQueries = 8;
+unsigned parallelQueryLoadThreads = 0;               // Number of threads to use for parallel loading of queries. 0 means don't (may cause CPU starvation on other vms)
 bool alwaysFailOnLeaks = false;
 SinkMode defaultSinkMode = SinkMode::Parallel;
 unsigned continuationCompressThreshold = 1024;
@@ -895,7 +894,7 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
         lowTimeout = topology->getPropInt("@lowTimeout", 10000);
         highTimeout = topology->getPropInt("@highTimeout", 2000);
         slaTimeout = topology->getPropInt("@slaTimeout", 2000);
-        parallelLoopFlowLimit = topology->getPropInt("@parallelLoopFlowLimit", 100);
+        parallelLoopFlowLimit = topology->getPropInt("@parallelLoopFlowLimit", parallelLoopFlowLimit);
         perChannelFlowLimit = topology->getPropInt("@perChannelFlowLimit", 10);
         copyResources = (!oneShotRoxie) && topology->getPropBool("@copyResources", true);
         useRemoteResources = oneShotRoxie || topology->getPropBool("@useRemoteResources", !isContainerized());
@@ -983,12 +982,17 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
         }
 
         updDataSendTimeout = topology->getPropInt("@udpDataSendTimeout", updDataSendTimeout);
-        udpResendTimeout = topology->getPropInt("@udpResendTimeout", udpResendTimeout);
+        udpResendDelay = topology->getPropInt("@udpResendDelay", udpResendDelay);
         udpMaxClientPercent = topology->getPropInt("@udpMaxClientPercent", udpMaxClientPercent);
 
         // MORE: might want to check socket buffer sizes against sys max here instead of udp threads ?
 
+#ifdef _CONTAINERIZED
+        udpMulticastBufferSize = topology->getPropInt("@udpAgentBufferSize", 262142);
+#else
         udpMulticastBufferSize = topology->getPropInt("@udpMulticastBufferSize", 262142);
+#endif
+
         udpFlowSocketsSize = topology->getPropInt("@udpFlowSocketsSize", udpFlowSocketsSize);
         udpLocalWriteSocketSize = topology->getPropInt("@udpLocalWriteSocketSize", udpLocalWriteSocketSize);
 #ifndef _CONTAINERIZED
@@ -1058,7 +1062,6 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
         agentQueryReleaseDelaySeconds = topology->getPropInt("@agentQueryReleaseDelaySeconds", topology->getPropInt("@slaveQueryReleaseDelaySeconds", 60));  // legacy name
         coresPerQuery = topology->getPropInt("@coresPerQuery", 0);
 
-        diskReadBufferSize = topology->getPropInt("@diskReadBufferSize", 0x10000);
         fieldTranslationEnabled = RecordTranslationMode::Payload;
         const char *val = topology->queryProp("@fieldTranslationEnabled");
         if (val)
@@ -1107,15 +1110,14 @@ int CCD_API roxie_main(int argc, const char *argv[], const char * defaultYaml)
         mergeAgentStatistics = topology->getPropBool("@mergeAgentStatistics", topology->getPropBool("@mergeSlaveStatistics", true));  // legacy name
         defaultCollectFactoryStatistics = topology->getPropBool("@collectFactoryStatistics", true);
         defaultNoSeekBuildIndex = topology->getPropBool("@noSeekBuildIndex", isContainerized());
-        parallelLoadQueries = topology->getPropInt("@parallelLoadQueries", 8);
-        if (!parallelLoadQueries)
-            parallelLoadQueries = 1;
+        parallelQueryLoadThreads = topology->getPropInt("@parallelQueryLoadThreads", parallelQueryLoadThreads);
+        if (!parallelQueryLoadThreads)
+            parallelQueryLoadThreads = 1;
         alwaysFailOnLeaks = topology->getPropBool("@alwaysFailOnLeaks", false);
         const char *sinkModeText = topology->queryProp("@sinkMode");
         if (sinkModeText)
             defaultSinkMode = getSinkMode(sinkModeText);
 
-        enableKeyDiff = topology->getPropBool("@enableKeyDiff", true);
         cacheReportPeriodSeconds = topology->getPropInt("@cacheReportPeriodSeconds", 5*60);
 
         // NB: these directories will have been setup by topology earlier

roxie/ccd/ccdqueue.cpp

@@ -2858,11 +2858,11 @@ public:
         }
 
         unsigned serverFlowPort = topology->getPropInt("@serverFlowPort", CCD_SERVER_FLOW_PORT);
-        bool sendFlowOnDataPort = topology->getPropBool("@sendFlowOnDataPort", true);
+        bool udpSendFlowOnDataPort = topology->getPropBool("@udpSendFlowOnDataPort", true);
         unsigned dataPort = topology->getPropInt("@dataPort", CCD_DATA_PORT);
         unsigned clientFlowPort = topology->getPropInt("@clientFlowPort", CCD_CLIENT_FLOW_PORT);
         receiveManager.setown(createReceiveManager(serverFlowPort, dataPort, clientFlowPort, udpQueueSize, encryptionInTransit));
-        sendManager.setown(createSendManager(sendFlowOnDataPort ? dataPort : serverFlowPort, dataPort, clientFlowPort, udpSendQueueSize, fastLaneQueue ? 3 : 2, myNode.getIpAddress(), bucket, encryptionInTransit));
+        sendManager.setown(createSendManager(udpSendFlowOnDataPort ? dataPort : serverFlowPort, dataPort, clientFlowPort, udpSendQueueSize, fastLaneQueue ? 3 : 2, myNode.getIpAddress(), bucket, encryptionInTransit));
     }
 
     virtual void abortPendingData(const SocketEndpoint &ep) override

roxie/ccd/ccdstate.cpp

@@ -977,7 +977,7 @@ public:
         if (numQueries)
         {
             std::vector<hash64_t> queryHashes(numQueries);
-            asyncFor(numQueries, parallelLoadQueries, [this, querySet, &packages, &queryHashes, forceRetry](unsigned i)
+            asyncFor(numQueries, parallelQueryLoadThreads, [this, querySet, &packages, &queryHashes, forceRetry](unsigned i)
             {
                 queryHashes[i] = 0;
                 VStringBuffer xpath("Query[%u]", i+1);
@@ -1034,7 +1034,7 @@ public:
         if (numAliases)
         {
             std::vector<hash64_t> aliasHashes(numAliases);
-            asyncFor(numAliases, parallelLoadQueries, [this, querySet, &aliasHashes](unsigned i)
+            asyncFor(numAliases, parallelQueryLoadThreads, [this, querySet, &aliasHashes](unsigned i)
             {
                 aliasHashes[i] = 0;
                 VStringBuffer xpath("Alias[%u]", i+1);
@@ -2301,16 +2301,6 @@ private:
                 unknown = true;
             break;
 
-        case 'E':
-            if (stricmp(queryName, "control:enableKeyDiff")==0)
-            {
-                enableKeyDiff = control->getPropBool("@val", true);
-                topology->setPropBool("@enableKeyDiff", enableKeyDiff);
-            }
-            else
-                unknown = true;
-            break;
-            
         case 'F':
             if (stricmp(queryName, "control:fieldTranslationEnabled")==0)
             {

roxie/udplib/udplib.hpp

@@ -213,7 +213,7 @@ extern UDPLIB_API unsigned udpFlowAckTimeout;
 extern UDPLIB_API unsigned updDataSendTimeout;
 extern UDPLIB_API unsigned udpRequestTimeout;
 extern UDPLIB_API unsigned udpPermitTimeout;
-extern UDPLIB_API unsigned udpResendTimeout;
+extern UDPLIB_API unsigned udpResendDelay;
 
 extern UDPLIB_API bool udpResendLostPackets;
 extern UDPLIB_API unsigned udpMaxPendingPermits;

roxie/udplib/udpsha.cpp

@@ -62,7 +62,7 @@ unsigned udpFlowAckTimeout = 2;         // [sender] the maximum time that it is
 unsigned updDataSendTimeout = 20;       // [sender+receiver] how long to receive the maximum amount of data, ~100 packets of 8K should take 10ms on a 1Gb network. Timeout for assuming send_complete has been lost
 unsigned udpRequestTimeout = 20;        // [sender] A reasonable expected time between a request for a permit until the permit is granted - used as a timeout to guard against an ok_to_send has been lost.
 unsigned udpPermitTimeout = 50;         // [receiver] How long is a grant expected to last before it is assumed lost?
-unsigned udpResendTimeout = 0;          // [sender+receiver] How long should elapse after a data packet has been sent before we assume it is lost.
+unsigned udpResendDelay = 0;            // [sender+receiver] How long should elapse after a data packet has been sent before we assume it is lost.
                                         // 0 means they are unlikely to be lost, so worth resending as soon as it appears to be missing - trading duplicate packets for delays (good if allowasync=false)
 
 unsigned udpMaxPendingPermits = 10;     // This seems like a reasonable compromise - each sender will be able to send up to 20% of the input queue each request.
@@ -514,7 +514,7 @@ void sanityCheckUdpSettings(unsigned receiveQueueSize, unsigned numSenders, __ui
         trace("updDataSendTimeout", updDataSendTimeout, minTimeForAllPackets, 10);
         trace("udpPermitTimeout", udpPermitTimeout, 2 * minLatencyNs + minTimeForPermitPackets, 10);
         trace("udpRequestTimeout", udpRequestTimeout, (2 * minLatencyNs + minTimeForPermitPackets) * 2 / 5, 10);
-        trace("udpResendTimeout", udpResendTimeout, minTimeForAllPackets, 10);
+        trace("udpResendDelay", udpResendDelay, minTimeForAllPackets, 10);
         DBGLOG("udpMaxPendingPermits: %u [%u..%u]", udpMaxPendingPermits, udpMaxPendingPermits, udpMaxPendingPermits);
         DBGLOG("udpMaxClientPercent: %u [%u..%u]", udpMaxClientPercent, 100, 500);
         DBGLOG("udpMaxPermitDeadTimeouts: %u [%u..%u]", udpMaxPermitDeadTimeouts, 2, 10);
@@ -527,13 +527,13 @@ void sanityCheckUdpSettings(unsigned receiveQueueSize, unsigned numSenders, __ui
         WARNLOG("udpResendLostPackets is currently disabled - only viable on a very reliable network");
     if (udpAllowAsyncPermits)
     {
-        if (udpResendTimeout == 0)
-            ERRLOG("udpResendTimeout of 0 should not be used if udpAllowAsyncPermits=true");
+        if (udpResendDelay == 0)
+            ERRLOG("udpResendDelay of 0 should not be used if udpAllowAsyncPermits=true");
     }
     else
     {
-        if (udpResendTimeout != 0)
-            WARNLOG("udpResendTimeout of 0 is recommended if udpAllowAsyncPermits=false");
+        if (udpResendDelay != 0)
+            WARNLOG("udpResendDelay of 0 is recommended if udpAllowAsyncPermits=false");
     }
     if (udpFlowAckTimeout == 0)
     {

roxie/udplib/udpsim.cpp

@@ -68,14 +68,14 @@ udpsim:
   updDataSendTimeout: 20
   udpRequestTimeout: 20
   udpPermitTimeout: 50
-  udpResendTimeout: 40
+  udpResendDelay: 0
   udpMaxPermitDeadTimeouts: 5
   udpRequestDeadTimeout: 10000
   udpMaxPendingPermits: 10
   udpMaxClientPercent: 200
   udpMinSlotsPerSender: 1
   udpAssumeSequential: false
-  udpAllowAsyncPermits: true
+  udpAllowAsyncPermits: false
   udpTraceLevel: 1
   udpTraceTimeouts: true
   udpTestSocketDelay: 0
@@ -185,7 +185,7 @@ void initOptions(int argc, const char **argv)
     udpRequestTimeout = options->getPropInt("@udpRequestTimeout", udpRequestTimeout);
     udpFlowAckTimeout = options->getPropInt("@udpFlowAckTimeout", udpFlowAckTimeout);
     updDataSendTimeout = options->getPropInt("@udpDataSendTimeout", updDataSendTimeout);
-    udpResendTimeout = options->getPropInt("@udpResendTimeout", udpResendTimeout);
+    udpResendDelay = options->getPropInt("@udpResendDelay", udpResendDelay);
     udpMaxPermitDeadTimeouts = options->getPropInt("@udpMaxPermitDeadTimeouts", udpMaxPermitDeadTimeouts);
     udpRequestDeadTimeout = options->getPropInt("@udpRequestDeadTimeout", udpRequestDeadTimeout);
 

roxie/udplib/udptrr.cpp

@@ -64,7 +64,7 @@ Timeouts:
                           => Timeout for a permit before it is assumed lost
                           [receiver] If rts received while permit is active, permit is resent.  If not complete within timeout,
                                      revoke the permit.
-    udpResendTimeout    - the time that should have elapsed before a missing data packet is resent
+    udpResendDelay      - the time that should have elapsed before a missing data packet is resent
                           (I think this only makes sense if a new permit can be granted before all the data has been received,
                           so the request to send more is sent to the flow port.)
                           0 means they are unlikely to be lost, so worth resending as soon as it appears to be missing - trading
@@ -181,7 +181,7 @@ because the extra flow messages or data packets will reduce the overall capacity
   Too high: lost send_begin will reduce the number of permits, lost request_to_send_more will delay the sender
   Too low: permits will expire while the data is being transferred - slots will be over-committed.
            sender will potentially re-request to send before all the data has been sent over the wire
-           which will cause all "missing" packets to be resent if udpResendTimeout is low.
+           which will cause all "missing" packets to be resent if udpResendDelay is low.
   Suggestion: If multiple permits, probably better to be too high than too low.
               E.g. The time to send and receive the data for all/half the slots?
 
@@ -196,7 +196,7 @@ because the extra flow messages or data packets will reduce the overall capacity
   Suggestion: Better to be too low than too high.  Similar to udpDataSendTimeout?  10 * the ack timeout?
               (If lower than the udpDataSendTimeout then the permit could be resent)
 
-* udpResendTimeout
+* udpResendDelay
   Too high: Missing packets will take a long time to be resent.
   Too low: If large proportion of packets reordered or dropped by the network packets will be sent unnecessarily
   Suggestion: Set it to lower than the permit timeout, I'm not sure we want to run on a network where that many packets are being lost!
@@ -234,7 +234,7 @@ Other udp settings
   The smallest number of slots to assign to a sender, defaults to 1.  Could increase to prevent lots of small permits being granted.
 
 * udpAssumeSequential
-  If the sender has received a later sequence data packet, then resend a non-received packet - regardless of the udpResendTimeout
+  If the sender has received a later sequence data packet, then resend a non-received packet - regardless of the udpResendDelay
 
 * udpResendAllMissingPackets
   Do no limit the number of missing packets sent to the size of the permit - send all that are ok to end.  The rationale is that
@@ -347,7 +347,7 @@ The main difference for asynchronous requests is that instead of sending request
 into two messages - send_complete sent to the data port, and a request_to_send_more to the flow port.
 
 What is the trade off for asynchronous requests?
-- Synchronous requests are received after the data, so it makes sense for udpResendTimeout to be 0 (i.e. send immediately).
+- Synchronous requests are received after the data, so it makes sense for udpResendDelay to be 0 (i.e. send immediately).
   This means that missing data packets are likely to be sent much more quickly.
 - Asynchronous requests allow a sender to start sending more data before the previous data has been read.  When
   there is a single sender this will significantly reduce the latency.
@@ -622,7 +622,7 @@ class CReceiveManager : implements IReceiveManager, public CInterface
             // We can send some if (a) the first available new packet is less than TRACKER_BITS above the first unreceived packet or
             // (b) we are assuming arrival in order, and there are some marked seen that are > first unseen OR
             // (c) the oldest in-flight packet has expired
-            if (!udpResendLostPackets || (udpResendTimeout == 0))
+            if (!udpResendLostPackets || (udpResendDelay == 0))
                 return true;
             {
                 CriticalBlock b(psCrit);
@@ -633,7 +633,7 @@ class CReceiveManager : implements IReceiveManager, public CInterface
             }
 
             //The best approximation to the oldest-inflight packet - because permits may have expired...
-            return (msTick()-lastPermitTime > udpResendTimeout);
+            return (msTick()-lastPermitTime > udpResendDelay);
         }
 
         void acknowledgeRequest(const IpAddress &returnAddress, sequence_t _flowSeq, sequence_t _sendSeq)
@@ -1181,7 +1181,7 @@ class CReceiveManager : implements IReceiveManager, public CInterface
                 }
 
                 //Hard to tell what should happen to the timeout - try again when the resend timeout will allow missing packets to be sent
-                unsigned missingPacketTimeout = std::max(udpResendTimeout, 1U);
+                unsigned missingPacketTimeout = std::max(udpResendDelay, 1U);
                 if (timeout > missingPacketTimeout)
                     timeout = missingPacketTimeout; // Hopefully one of the senders should unblock soon
             }

roxie/udplib/udptrs.cpp

@@ -154,7 +154,7 @@ public:
                 else
                 {
                     // The current table entry is not marked as seen by receiver. Should we resend it?
-                    if (now-timeSent[idx] >= udpResendTimeout ||    // Note that this will block us from sending newer packets, if we have reached limit of tracking.
+                    if (now-timeSent[idx] >= udpResendDelay ||    // Note that this will block us from sending newer packets, if we have reached limit of tracking.
                         (udpAssumeSequential && (int)(seq - seen.lastSeen()) < 0))  // so we (optionally) assume any packet not received that is EARLIER than one that HAS been received is lost.
                     {
                         if (udpTraceLevel > 1 || udpTraceTimeouts)

testing/regress/environment.xml.in

@@ -59,7 +59,6 @@
                 defaultStripLeadingWhitespace="1"
                 description="Roxie cluster"
                 directory="${RUNTIME_PATH}/myroxie"
-                diskReadBufferSize="65536"
                 doIbytiDelay="true"
                 enableHeartBeat="true"
                 enableKeyDiff="true"

testing/udp/runall.sh

@@ -10,8 +10,8 @@ drop5="--dropDataPackets=1 --dropDataPacketsPercent=5 --dropOkToSendPackets=20 -
 drop50="--dropDataPackets=1 --dropDataPacketsPercent=50 --dropOkToSendPackets=2 --dropRequestReceivedPackets=2 --dropRequestToSendPackets=2 --dropRequestToSendMorePackets=2 --dropSendCompletedPackets=2   --dropSendStartPackets=2"
 
 legacy=""
-sync="--udpAllowAsyncPermits=0 --udpResendTimeout=0"
-async="--udpAllowAsyncPermits=1 --udpResendTimeout=1"
+sync="--udpAllowAsyncPermits=0 --udpResendDelay=0"
+async="--udpAllowAsyncPermits=1 --udpResendDelay=1"
 synclegacy="$sync --udpMaxPendingPermits=1"
 sync10p="$sync --udpMaxClientPercent=100"
 sync20p="$sync --udpMaxClientPercent=200"
@@ -269,9 +269,9 @@ then
     doit "$async --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1d" async10d1
     doit "$async --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1p" async10p1
 
-    # What performance difference does the resend timeout make?
-    doit "$async --udpResendTimeout=1 --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1dp" async10dp1t1
-    doit "$async --udpResendTimeout=5 --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1dp" async10dp1
-    doit "$async --udpResendTimeout=20 --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1d" async10d1t20
-    doit "$async --udpResendTimeout=50 --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1d" async10d1t50
+    # What performance difference does the resend delay make?
+    doit "$async --udpResendDelay=1 --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1dp" async10dp1t1
+    doit "$async --udpResendDelay=5 --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1dp" async10dp1
+    doit "$async --udpResendDelay=20 --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1d" async10d1t20
+    doit "$async --udpResendDelay=50 --numThreads=10 --packetsPerThread=100000 --udpTraceTimeouts=0 $drop1d" async10d1t50
 fi