diff --git a/docs/Settings.md b/docs/Settings.md
index 485e505a61..07117cd360 100644
--- a/docs/Settings.md
+++ b/docs/Settings.md
@@ -113,7 +113,7 @@ These parameters are accessed by calling [GetParam](./api/GetParam.md) or [SetPa
 | `QUIC_PARAM_GLOBAL_GLOBAL_SETTINGS`<br> 6         | QUIC_GLOBAL_SETTINGS    | Both      | Globally change global only settings.                                                                 |
 | `QUIC_PARAM_GLOBAL_VERSION_SETTINGS`<br> 7        | QUIC_VERSIONS_SETTINGS  | Both      | Globally change version settings for all subsequent connections.                                      |
 | `QUIC_PARAM_GLOBAL_LIBRARY_GIT_HASH`<br> 8        | char[64]                | Get-only  | Git hash used to build MsQuic (null terminated string)                                                |
-| `QUIC_PARAM_GLOBAL_EXECUTION_CONFIG`<br> 9        | QUIC_EXECUTION_CONFIG   | Both      | Globally configure the execution model used for QUIC. Must be set before opening registration.        |
+| `QUIC_PARAM_GLOBAL_EXECUTION_CONFIG`<br> 9 (preview)        | QUIC_GLOBAL_EXECUTION_CONFIG   | Both      | Globally configure the execution model used for QUIC. Must be set before opening registration.        |
 | `QUIC_PARAM_GLOBAL_TLS_PROVIDER`<br> 10           | QUIC_TLS_PROVIDER       | Get-Only  | The TLS provider being used by MsQuic for the TLS handshake.                                          |
 | `QUIC_PARAM_GLOBAL_STATELESS_RESET_KEY`<br> 11    | uint8_t[]               | Set-Only  | Globally change the stateless reset key for all subsequent connections.                               |
 | `QUIC_PARAM_GLOBAL_VERSION_NEGOTIATION_ENABLED`<br> (preview) | uint8_t (BOOLEAN) | Both | Globally enable the version negotiation extension for all client and server connections. |
diff --git a/scripts/generate-dotnet.ps1 b/scripts/generate-dotnet.ps1
index 22844e17ec..e1847ba4f8 100644
--- a/scripts/generate-dotnet.ps1
+++ b/scripts/generate-dotnet.ps1
@@ -80,7 +80,7 @@ Invoke-Expression "$ToolExe $FullArgs"
     -replace "  QUIC_RECEIVE_FLAG_", "  " `
     -replace "  QUIC_SEND_FLAG_", "  " `
     -replace "  QUIC_DATAGRAM_SEND_", "  " `
-    -replace "  QUIC_EXECUTION_CONFIG_FLAG_", "  " `
+    -replace "  QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_", "  " `
     -replace "QUIC_TLS_PROTOCOL_1_3", "TLS_1_3" `
     -replace "  QUIC_TLS_PROTOCOL_", "  " `
     -replace "  QUIC_CIPHER_ALGORITHM_", "  " `
diff --git a/src/core/library.c b/src/core/library.c
index a78c057cab..3cf90c53bb 100644
--- a/src/core/library.c
+++ b/src/core/library.c
@@ -1013,13 +1013,13 @@ QuicLibrarySetGlobalParam(
             return QUIC_STATUS_SUCCESS;
         }
 
-        if (Buffer == NULL || BufferLength < QUIC_EXECUTION_CONFIG_MIN_SIZE) {
+        if (Buffer == NULL || BufferLength < QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE) {
             return QUIC_STATUS_INVALID_PARAMETER;
         }
 
-        QUIC_EXECUTION_CONFIG* Config = (QUIC_EXECUTION_CONFIG*)Buffer;
+        QUIC_GLOBAL_EXECUTION_CONFIG* Config = (QUIC_GLOBAL_EXECUTION_CONFIG*)Buffer;
 
-        if (BufferLength < QUIC_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t) * Config->ProcessorCount) {
+        if (BufferLength < QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t) * Config->ProcessorCount) {
             return QUIC_STATUS_INVALID_PARAMETER;
         }
 
@@ -1051,7 +1051,7 @@ QuicLibrarySetGlobalParam(
             break;
         }
 
-        QUIC_EXECUTION_CONFIG* NewConfig =
+        QUIC_GLOBAL_EXECUTION_CONFIG* NewConfig =
             CXPLAT_ALLOC_NONPAGED(BufferLength, QUIC_POOL_EXECUTION_CONFIG);
         if (NewConfig == NULL) {
             QuicTraceEvent(
@@ -1340,7 +1340,7 @@ QuicLibraryGetGlobalParam(
         }
 
         const uint32_t ConfigLength =
-            QUIC_EXECUTION_CONFIG_MIN_SIZE +
+            QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE +
             sizeof(uint16_t) * MsQuicLib.ExecutionConfig->ProcessorCount;
 
         if (*BufferLength < ConfigLength) {
diff --git a/src/core/library.h b/src/core/library.h
index 17509ee522..2d1c3a9611 100644
--- a/src/core/library.h
+++ b/src/core/library.h
@@ -170,7 +170,7 @@ typedef struct QUIC_LIBRARY {
     //
     // Configuration for execution of the library (optionally set by the app).
     //
-    QUIC_EXECUTION_CONFIG* ExecutionConfig;
+    QUIC_GLOBAL_EXECUTION_CONFIG* ExecutionConfig;
 
     //
     // Datapath instance for the library.
diff --git a/src/core/unittest/SettingsTest.cpp b/src/core/unittest/SettingsTest.cpp
index 7a1f9f9ebf..d181e57787 100644
--- a/src/core/unittest/SettingsTest.cpp
+++ b/src/core/unittest/SettingsTest.cpp
@@ -559,8 +559,8 @@ TEST(SettingsTest, GlobalLoadBalancingServerIDSet)
 #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
 TEST(SettingsTest, GlobalExecutionConfigSetAndGet)
 {
-    uint8_t RawConfig[QUIC_EXECUTION_CONFIG_MIN_SIZE + 2 * sizeof(uint16_t)] = {0};
-    QUIC_EXECUTION_CONFIG* Config = (QUIC_EXECUTION_CONFIG*)RawConfig;
+    uint8_t RawConfig[QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + 2 * sizeof(uint16_t)] = {0};
+    QUIC_GLOBAL_EXECUTION_CONFIG* Config = (QUIC_GLOBAL_EXECUTION_CONFIG*)RawConfig;
     Config->ProcessorCount = 2;
     if (CxPlatProcCount() < 2) {
         Config->ProcessorCount = CxPlatProcCount();
@@ -586,7 +586,7 @@ TEST(SettingsTest, GlobalExecutionConfigSetAndGet)
             nullptr));
     ASSERT_EQ((uint32_t)sizeof(RawConfig), BufferLength);
     uint16_t GetRawConfig[sizeof(RawConfig)] = {0};
-    QUIC_EXECUTION_CONFIG* GetConfig = (QUIC_EXECUTION_CONFIG*)GetRawConfig;
+    QUIC_GLOBAL_EXECUTION_CONFIG* GetConfig = (QUIC_GLOBAL_EXECUTION_CONFIG*)GetRawConfig;
     ASSERT_EQ(
         QUIC_STATUS_SUCCESS,
         QuicLibraryGetGlobalParam(
@@ -629,8 +629,8 @@ TEST(SettingsTest, GlobalExecutionConfigSetAndGet)
 
 TEST(SettingsTest, GlobalRawDataPathProcsSetAfterDataPathInit)
 {
-    uint8_t RawConfig[QUIC_EXECUTION_CONFIG_MIN_SIZE + 2 * sizeof(uint16_t)] = {0};
-    QUIC_EXECUTION_CONFIG* Config = (QUIC_EXECUTION_CONFIG*)RawConfig;
+    uint8_t RawConfig[QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + 2 * sizeof(uint16_t)] = {0};
+    QUIC_GLOBAL_EXECUTION_CONFIG* Config = (QUIC_GLOBAL_EXECUTION_CONFIG*)RawConfig;
     Config->ProcessorCount = 2;
     Config->ProcessorList[0] = 0;
     Config->ProcessorList[1] = 1;
diff --git a/src/core/worker.c b/src/core/worker.c
index c656a002e9..f12d4e0d94 100644
--- a/src/core/worker.c
+++ b/src/core/worker.c
@@ -115,10 +115,10 @@ QuicWorkerInitialize(
         }
 
         if (MsQuicLib.ExecutionConfig) {
-            if (MsQuicLib.ExecutionConfig->Flags & QUIC_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY) {
+            if (MsQuicLib.ExecutionConfig->Flags & QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY) {
                 ThreadFlags |= CXPLAT_THREAD_FLAG_HIGH_PRIORITY;
             }
-            if (MsQuicLib.ExecutionConfig->Flags & QUIC_EXECUTION_CONFIG_FLAG_AFFINITIZE) {
+            if (MsQuicLib.ExecutionConfig->Flags & QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_AFFINITIZE) {
                 ThreadFlags |= CXPLAT_THREAD_FLAG_SET_AFFINITIZE;
             }
         }
diff --git a/src/cs/lib/msquic_generated.cs b/src/cs/lib/msquic_generated.cs
index ecc269ae26..664186d875 100644
--- a/src/cs/lib/msquic_generated.cs
+++ b/src/cs/lib/msquic_generated.cs
@@ -213,7 +213,7 @@ internal enum QUIC_DATAGRAM_SEND_STATE
     }
 
     [System.Flags]
-    internal enum QUIC_EXECUTION_CONFIG_FLAGS
+    internal enum QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS
     {
         NONE = 0x0000,
         RIO = 0x0002,
@@ -223,9 +223,9 @@ internal enum QUIC_EXECUTION_CONFIG_FLAGS
         AFFINITIZE = 0x0020,
     }
 
-    internal unsafe partial struct QUIC_EXECUTION_CONFIG
+    internal unsafe partial struct QUIC_GLOBAL_EXECUTION_CONFIG
     {
-        internal QUIC_EXECUTION_CONFIG_FLAGS Flags;
+        internal QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS Flags;
 
         [NativeTypeName("uint32_t")]
         internal uint PollingIdleTimeoutUs;
@@ -3419,8 +3419,8 @@ internal static unsafe partial class MsQuic
         [NativeTypeName("#define QUIC_STATELESS_RESET_KEY_LENGTH 32")]
         internal const uint QUIC_STATELESS_RESET_KEY_LENGTH = 32;
 
-        [NativeTypeName("#define QUIC_EXECUTION_CONFIG_MIN_SIZE (uint32_t)FIELD_OFFSET(QUIC_EXECUTION_CONFIG, ProcessorList)")]
-        internal static readonly uint QUIC_EXECUTION_CONFIG_MIN_SIZE = unchecked((uint)((int)(Marshal.OffsetOf<QUIC_EXECUTION_CONFIG>("ProcessorList"))));
+        [NativeTypeName("#define QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE (uint32_t)FIELD_OFFSET(QUIC_GLOBAL_EXECUTION_CONFIG, ProcessorList)")]
+        internal static readonly uint QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE = unchecked((uint)((int)(Marshal.OffsetOf<QUIC_GLOBAL_EXECUTION_CONFIG>("ProcessorList"))));
 
         [NativeTypeName("#define QUIC_MAX_TICKET_KEY_COUNT 16")]
         internal const uint QUIC_MAX_TICKET_KEY_COUNT = 16;
diff --git a/src/inc/msquic.h b/src/inc/msquic.h
index 15e5e7fd7f..6413b7785f 100644
--- a/src/inc/msquic.h
+++ b/src/inc/msquic.h
@@ -270,34 +270,34 @@ typedef enum QUIC_DATAGRAM_SEND_STATE {
 #define QUIC_DATAGRAM_SEND_STATE_IS_FINAL(State) \
     ((State) >= QUIC_DATAGRAM_SEND_LOST_DISCARDED)
 
-typedef enum QUIC_EXECUTION_CONFIG_FLAGS {
-    QUIC_EXECUTION_CONFIG_FLAG_NONE             = 0x0000,
+typedef enum QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS {
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE             = 0x0000,
 #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
-    QUIC_EXECUTION_CONFIG_FLAG_RIO              = 0x0002,
-    QUIC_EXECUTION_CONFIG_FLAG_XDP              = 0x0004,
-    QUIC_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC    = 0x0008,
-    QUIC_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY    = 0x0010,
-    QUIC_EXECUTION_CONFIG_FLAG_AFFINITIZE       = 0x0020,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_RIO              = 0x0002,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP              = 0x0004,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC    = 0x0008,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY    = 0x0010,
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_AFFINITIZE       = 0x0020,
 #endif
-} QUIC_EXECUTION_CONFIG_FLAGS;
+} QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS;
 
-DEFINE_ENUM_FLAG_OPERATORS(QUIC_EXECUTION_CONFIG_FLAGS)
+DEFINE_ENUM_FLAG_OPERATORS(QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS)
 
 //
 // A custom configuration for thread execution in QUIC.
 //
-typedef struct QUIC_EXECUTION_CONFIG {
+typedef struct QUIC_GLOBAL_EXECUTION_CONFIG {
 
-    QUIC_EXECUTION_CONFIG_FLAGS Flags;
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS Flags;
     uint32_t PollingIdleTimeoutUs;      // Time before a polling thread, with no work to do, sleeps.
     uint32_t ProcessorCount;
     _Field_size_(ProcessorCount)
     uint16_t ProcessorList[1];          // List of processors to use for threads.
 
-} QUIC_EXECUTION_CONFIG;
+} QUIC_GLOBAL_EXECUTION_CONFIG;
 
-#define QUIC_EXECUTION_CONFIG_MIN_SIZE \
-    (uint32_t)FIELD_OFFSET(QUIC_EXECUTION_CONFIG, ProcessorList)
+#define QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE \
+    (uint32_t)FIELD_OFFSET(QUIC_GLOBAL_EXECUTION_CONFIG, ProcessorList)
 
 typedef struct QUIC_REGISTRATION_CONFIG { // All fields may be NULL/zero.
     const char* AppName;
@@ -863,7 +863,7 @@ void
 #endif
 #define QUIC_PARAM_GLOBAL_LIBRARY_GIT_HASH              0x01000008  // char[64]
 #ifdef QUIC_API_ENABLE_PREVIEW_FEATURES
-#define QUIC_PARAM_GLOBAL_EXECUTION_CONFIG              0x01000009  // QUIC_EXECUTION_CONFIG
+#define QUIC_PARAM_GLOBAL_EXECUTION_CONFIG              0x01000009  // QUIC_GLOBAL_EXECUTION_CONFIG
 #endif
 #define QUIC_PARAM_GLOBAL_TLS_PROVIDER                  0x0100000A  // QUIC_TLS_PROVIDER
 #define QUIC_PARAM_GLOBAL_STATELESS_RESET_KEY           0x0100000B  // uint8_t[] - Array size is QUIC_STATELESS_RESET_KEY_LENGTH
diff --git a/src/inc/msquic.hpp b/src/inc/msquic.hpp
index 74aa68b45e..00ec76b5e7 100644
--- a/src/inc/msquic.hpp
+++ b/src/inc/msquic.hpp
@@ -1743,4 +1743,4 @@ struct QuicBufferScope {
 
 static_assert(sizeof(QuicBufferScope) == sizeof(QUIC_BUFFER*), "Scope guards should be the same size as the guarded type");
 
-#endif  //  _WIN32
+#endif  //  _MSQUIC_HPP_
diff --git a/src/inc/quic_datapath.h b/src/inc/quic_datapath.h
index 1082f70dbc..ae3d7a0fa9 100644
--- a/src/inc/quic_datapath.h
+++ b/src/inc/quic_datapath.h
@@ -447,7 +447,7 @@ CxPlatDataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _Out_ CXPLAT_DATAPATH** NewDatapath
     );
 
@@ -467,7 +467,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 #define CXPLAT_DATAPATH_FEATURE_RECV_SIDE_SCALING     0x0001
diff --git a/src/inc/quic_platform.h b/src/inc/quic_platform.h
index ec53487996..894c9413de 100644
--- a/src/inc/quic_platform.h
+++ b/src/inc/quic_platform.h
@@ -444,7 +444,7 @@ CxPlatGetAllocFailDenominator(
 // loops.
 //
 
-typedef struct QUIC_EXECUTION_CONFIG QUIC_EXECUTION_CONFIG;
+typedef struct QUIC_GLOBAL_EXECUTION_CONFIG QUIC_GLOBAL_EXECUTION_CONFIG;
 
 typedef struct CXPLAT_EXECUTION_CONTEXT CXPLAT_EXECUTION_CONTEXT;
 
@@ -467,7 +467,7 @@ typedef struct CXPLAT_WORKER_POOL CXPLAT_WORKER_POOL;
 
 CXPLAT_WORKER_POOL*
 CxPlatWorkerPoolCreate(
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 void
diff --git a/src/perf/lib/SecNetPerfMain.cpp b/src/perf/lib/SecNetPerfMain.cpp
index 2594d253fe..355f69212b 100644
--- a/src/perf/lib/SecNetPerfMain.cpp
+++ b/src/perf/lib/SecNetPerfMain.cpp
@@ -177,8 +177,8 @@ QuicMainStart(
         return Status;
     }
 
-    uint8_t RawConfig[QUIC_EXECUTION_CONFIG_MIN_SIZE + 256 * sizeof(uint16_t)] = {0};
-    QUIC_EXECUTION_CONFIG* Config = (QUIC_EXECUTION_CONFIG*)RawConfig;
+    uint8_t RawConfig[QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + 256 * sizeof(uint16_t)] = {0};
+    QUIC_GLOBAL_EXECUTION_CONFIG* Config = (QUIC_GLOBAL_EXECUTION_CONFIG*)RawConfig;
     Config->PollingIdleTimeoutUs = 0; // Default to no polling.
     bool SetConfig = false;
     const char* IoMode = GetValue(argc, argv, "io");
@@ -186,14 +186,14 @@ QuicMainStart(
 #ifndef _KERNEL_MODE
 
     if (IoMode && IsValue(IoMode, "rio")) {
-        Config->Flags |= QUIC_EXECUTION_CONFIG_FLAG_RIO;
+        Config->Flags |= QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_RIO;
         SetConfig = true;
     }
 
 #endif // _KERNEL_MODE
 
     if (IoMode && IsValue(IoMode, "xdp")) {
-        Config->Flags |= QUIC_EXECUTION_CONFIG_FLAG_XDP;
+        Config->Flags |= QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP;
         SetConfig = true;
     }
 
@@ -215,13 +215,13 @@ QuicMainStart(
 
     TryGetValue(argc, argv, "highpri", &PerfDefaultHighPriority);
     if (PerfDefaultHighPriority) {
-        Config->Flags |= QUIC_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY;
+        Config->Flags |= QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY;
         SetConfig = true;
     }
 
     TryGetValue(argc, argv, "affinitize", &PerfDefaultAffinitizeThreads);
     if (PerfDefaultHighPriority) {
-        Config->Flags |= QUIC_EXECUTION_CONFIG_FLAG_AFFINITIZE;
+        Config->Flags |= QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_AFFINITIZE;
         SetConfig = true;
     }
 
@@ -235,7 +235,7 @@ QuicMainStart(
         MsQuic->SetParam(
             nullptr,
             QUIC_PARAM_GLOBAL_EXECUTION_CONFIG,
-            (uint32_t)QUIC_EXECUTION_CONFIG_MIN_SIZE + Config->ProcessorCount * sizeof(uint16_t),
+            (uint32_t)QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + Config->ProcessorCount * sizeof(uint16_t),
             Config))) {
         WriteOutput("Failed to set execution config %d\n", Status);
         return Status;
diff --git a/src/platform/datapath_epoll.c b/src/platform/datapath_epoll.c
index 65e46c5a40..6352562074 100644
--- a/src/platform/datapath_epoll.c
+++ b/src/platform/datapath_epoll.c
@@ -360,7 +360,7 @@ DataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _Out_ CXPLAT_DATAPATH** NewDatapath
     )
 {
@@ -485,7 +485,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 DataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Datapath);
diff --git a/src/platform/datapath_kqueue.c b/src/platform/datapath_kqueue.c
index d1d77783f1..cd57b19c93 100644
--- a/src/platform/datapath_kqueue.c
+++ b/src/platform/datapath_kqueue.c
@@ -434,7 +434,7 @@ CxPlatDataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _Out_ CXPLAT_DATAPATH** NewDataPath
     )
 {
@@ -546,7 +546,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Datapath);
diff --git a/src/platform/datapath_raw.c b/src/platform/datapath_raw.c
index 285e0bbf9d..5c0f97319a 100644
--- a/src/platform/datapath_raw.c
+++ b/src/platform/datapath_raw.c
@@ -22,7 +22,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 QUIC_STATUS
 RawDataPathInitialize(
     _In_ uint32_t ClientRecvContextLength,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _In_opt_ const CXPLAT_DATAPATH* ParentDataPath,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
     _Out_ CXPLAT_DATAPATH_RAW** NewDataPath
@@ -133,7 +133,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 RawDataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH_RAW* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     CxPlatDpRawUpdateConfig(Datapath, Config);;
diff --git a/src/platform/datapath_raw.h b/src/platform/datapath_raw.h
index b1feee9326..a04f54f715 100644
--- a/src/platform/datapath_raw.h
+++ b/src/platform/datapath_raw.h
@@ -113,7 +113,7 @@ CxPlatDpRawInitialize(
     _Inout_ CXPLAT_DATAPATH_RAW* Datapath,
     _In_ uint32_t ClientRecvContextLength,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 //
@@ -141,7 +141,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDpRawUpdateConfig(
     _In_ CXPLAT_DATAPATH_RAW* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 //
diff --git a/src/platform/datapath_raw_dpdk.c b/src/platform/datapath_raw_dpdk.c
index 59706a55ed..f338ecce9e 100644
--- a/src/platform/datapath_raw_dpdk.c
+++ b/src/platform/datapath_raw_dpdk.c
@@ -126,7 +126,7 @@ CxPlatDpdkReadConfig(
 _IRQL_requires_max_(PASSIVE_LEVEL)
 size_t
 CxPlatDpRawGetDatapathSize(
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Config);
@@ -139,7 +139,7 @@ CxPlatDpRawInitialize(
     _Inout_ CXPLAT_DATAPATH* Datapath,
     _In_ uint32_t ClientRecvContextLength,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(WorkerPool);
@@ -214,7 +214,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDpRawUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Datapath);
diff --git a/src/platform/datapath_raw_dummy.c b/src/platform/datapath_raw_dummy.c
index 5fc69b879d..2372f3e14c 100644
--- a/src/platform/datapath_raw_dummy.c
+++ b/src/platform/datapath_raw_dummy.c
@@ -54,7 +54,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 QUIC_STATUS
 RawDataPathInitialize(
     _In_ uint32_t ClientRecvContextLength,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _In_opt_ const CXPLAT_DATAPATH* ParentDataPath,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
     _Out_ CXPLAT_DATAPATH_RAW** DataPath
@@ -81,7 +81,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 RawDataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH_RAW* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Datapath);
diff --git a/src/platform/datapath_raw_xdp_linux.c b/src/platform/datapath_raw_xdp_linux.c
index afb7c61501..0b2efad9df 100644
--- a/src/platform/datapath_raw_xdp_linux.c
+++ b/src/platform/datapath_raw_xdp_linux.c
@@ -646,7 +646,7 @@ CxPlatDpRawInterfaceUpdateRules(
 _IRQL_requires_max_(PASSIVE_LEVEL)
 size_t
 CxPlatDpRawGetDatapathSize(
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     const uint32_t PartitionCount =
@@ -676,7 +676,7 @@ CxPlatDpRawInitialize(
     _Inout_ CXPLAT_DATAPATH_RAW* Datapath,
     _In_ uint32_t ClientRecvContextLength,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     XDP_DATAPATH* Xdp = (XDP_DATAPATH*)Datapath;
@@ -914,7 +914,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDpRawUpdateConfig(
     _In_ CXPLAT_DATAPATH_RAW* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     XDP_DATAPATH* Xdp = (XDP_DATAPATH*)Datapath;
diff --git a/src/platform/datapath_raw_xdp_win.c b/src/platform/datapath_raw_xdp_win.c
index b0efe3bd27..49c977211f 100644
--- a/src/platform/datapath_raw_xdp_win.c
+++ b/src/platform/datapath_raw_xdp_win.c
@@ -925,7 +925,7 @@ CxPlatDpRawInterfaceRemoveRules(
 _IRQL_requires_max_(PASSIVE_LEVEL)
 size_t
 CxPlatDpRawGetDatapathSize(
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     const uint32_t PartitionCount =
@@ -939,7 +939,7 @@ CxPlatDpRawInitialize(
     _Inout_ CXPLAT_DATAPATH_RAW* Datapath,
     _In_ uint32_t ClientRecvContextLength,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     XDP_DATAPATH* Xdp = (XDP_DATAPATH*)Datapath;
@@ -1232,7 +1232,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDpRawUpdateConfig(
     _In_ CXPLAT_DATAPATH_RAW* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     XDP_DATAPATH* Xdp = (XDP_DATAPATH*)Datapath;
diff --git a/src/platform/datapath_winkernel.c b/src/platform/datapath_winkernel.c
index 28418ec04d..69c8e514eb 100644
--- a/src/platform/datapath_winkernel.c
+++ b/src/platform/datapath_winkernel.c
@@ -683,7 +683,7 @@ DataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _Out_ CXPLAT_DATAPATH* *NewDataPath
     )
 {
@@ -923,7 +923,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 DataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Datapath);
diff --git a/src/platform/datapath_winuser.c b/src/platform/datapath_winuser.c
index b07d80b14c..4f16f0ad7f 100644
--- a/src/platform/datapath_winuser.c
+++ b/src/platform/datapath_winuser.c
@@ -753,7 +753,7 @@ DataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config, // TODO:: If we move RIO to a per-socket option, we can remove this from all datapaths
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config, // TODO:: If we move RIO to a per-socket option, we can remove this from all datapaths
     _Out_ CXPLAT_DATAPATH** NewDatapath
     )
 {
@@ -818,7 +818,7 @@ DataPathInitialize(
 
     Datapath->PartitionCount = (uint16_t)CxPlatWorkerPoolGetCount(WorkerPool);
     CxPlatRefInitializeEx(&Datapath->RefCount, Datapath->PartitionCount);
-    Datapath->UseRio = Config && !!(Config->Flags & QUIC_EXECUTION_CONFIG_FLAG_RIO);
+    Datapath->UseRio = Config && !!(Config->Flags & QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_RIO);
 
     CxPlatDataPathQueryRssScalabilityInfo(Datapath);
     Status = CxPlatDataPathQuerySockoptSupport(Datapath);
@@ -1015,7 +1015,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 DataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     UNREFERENCED_PARAMETER(Datapath);
diff --git a/src/platform/datapath_xplat.c b/src/platform/datapath_xplat.c
index 99cb714828..94732d3477 100644
--- a/src/platform/datapath_xplat.c
+++ b/src/platform/datapath_xplat.c
@@ -22,7 +22,7 @@ CxPlatDataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _Out_ CXPLAT_DATAPATH** NewDataPath
     )
 {
@@ -47,7 +47,7 @@ CxPlatDataPathInitialize(
         goto Error;
     }
 
-    if (Config && Config->Flags & QUIC_EXECUTION_CONFIG_FLAG_XDP) {
+    if (Config && Config->Flags & QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP) {
         Status =
             RawDataPathInitialize(
                 ClientRecvContextLength,
@@ -86,7 +86,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 CxPlatDataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     DataPathUpdateConfig(Datapath, Config);
diff --git a/src/platform/platform_internal.h b/src/platform/platform_internal.h
index 56d31ce06e..a507422d9b 100644
--- a/src/platform/platform_internal.h
+++ b/src/platform/platform_internal.h
@@ -778,7 +778,7 @@ CxPlatCryptUninitialize(
 _IRQL_requires_max_(PASSIVE_LEVEL)
 size_t
 CxPlatDpRawGetDatapathSize(
-    _In_opt_ const QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ const QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 #if defined(CX_PLATFORM_LINUX)
@@ -1068,7 +1068,7 @@ DataPathInitialize(
     _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
     _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _Out_ CXPLAT_DATAPATH** NewDatapath
     );
 
@@ -1082,7 +1082,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 DataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 _IRQL_requires_max_(DISPATCH_LEVEL)
@@ -1177,7 +1177,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 QUIC_STATUS
 RawDataPathInitialize(
     _In_ uint32_t ClientRecvContextLength,
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config,
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config,
     _In_opt_ const CXPLAT_DATAPATH* ParentDataPath,
     _In_ CXPLAT_WORKER_POOL* WorkerPool,
     _Out_ CXPLAT_DATAPATH_RAW** DataPath
@@ -1193,7 +1193,7 @@ _IRQL_requires_max_(PASSIVE_LEVEL)
 void
 RawDataPathUpdateConfig(
     _In_ CXPLAT_DATAPATH_RAW* Datapath,
-    _In_ QUIC_EXECUTION_CONFIG* Config
+    _In_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     );
 
 _IRQL_requires_max_(DISPATCH_LEVEL)
diff --git a/src/platform/platform_worker.c b/src/platform/platform_worker.c
index 23fb6c4a70..9f946f05b9 100644
--- a/src/platform/platform_worker.c
+++ b/src/platform/platform_worker.c
@@ -149,7 +149,7 @@ UpdatePollCompletion(
 #pragma warning(disable:6386) // SAL is confused about the worker size
 CXPLAT_WORKER_POOL*
 CxPlatWorkerPoolCreate(
-    _In_opt_ QUIC_EXECUTION_CONFIG* Config
+    _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config
     )
 {
     //
@@ -191,13 +191,13 @@ CxPlatWorkerPoolCreate(
     //
     uint16_t ThreadFlags = CXPLAT_THREAD_FLAG_SET_IDEAL_PROC;
     if (Config) {
-        if (Config->Flags & QUIC_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC) {
+        if (Config->Flags & QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC) {
             ThreadFlags &= ~CXPLAT_THREAD_FLAG_SET_IDEAL_PROC; // Remove the flag
         }
-        if (Config->Flags & QUIC_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY) {
+        if (Config->Flags & QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY) {
             ThreadFlags |= CXPLAT_THREAD_FLAG_HIGH_PRIORITY;
         }
-        if (Config->Flags & QUIC_EXECUTION_CONFIG_FLAG_AFFINITIZE) {
+        if (Config->Flags & QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_AFFINITIZE) {
             ThreadFlags |= CXPLAT_THREAD_FLAG_SET_AFFINITIZE;
         }
     }
diff --git a/src/platform/unittest/DataPathTest.cpp b/src/platform/unittest/DataPathTest.cpp
index 5ae541b6d6..24db8303fb 100644
--- a/src/platform/unittest/DataPathTest.cpp
+++ b/src/platform/unittest/DataPathTest.cpp
@@ -450,7 +450,7 @@ QuicAddr DataPathTest::UnspecIPv4;
 QuicAddr DataPathTest::UnspecIPv6;
 
 struct CxPlatDataPath {
-    QUIC_EXECUTION_CONFIG DefaultExecutionConfig { QUIC_EXECUTION_CONFIG_FLAG_NONE, 0, 0, {0} };
+    QUIC_GLOBAL_EXECUTION_CONFIG DefaultExecutionConfig { QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE, 0, 0, {0} };
     CXPLAT_WORKER_POOL* WorkerPool {nullptr};
     CXPLAT_DATAPATH* Datapath {nullptr};
     QUIC_STATUS InitStatus;
@@ -458,11 +458,11 @@ struct CxPlatDataPath {
         _In_opt_ const CXPLAT_UDP_DATAPATH_CALLBACKS* UdpCallbacks,
         _In_opt_ const CXPLAT_TCP_DATAPATH_CALLBACKS* TcpCallbacks = nullptr,
         _In_ uint32_t ClientRecvContextLength = 0,
-        _In_opt_ QUIC_EXECUTION_CONFIG* Config = nullptr
+        _In_opt_ QUIC_GLOBAL_EXECUTION_CONFIG* Config = nullptr
         ) noexcept
     {
         if (UseDuoNic && Config == nullptr) {
-            DefaultExecutionConfig.Flags = QUIC_EXECUTION_CONFIG_FLAG_XDP;
+            DefaultExecutionConfig.Flags = QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP;
         }
         WorkerPool =
             CxPlatWorkerPoolCreate(Config ? Config : &DefaultExecutionConfig);
@@ -679,25 +679,25 @@ TEST_F(DataPathTest, Initialize)
         ASSERT_NE(nullptr, Datapath.Datapath);
     }
     {
-        QUIC_EXECUTION_CONFIG Config = { QUIC_EXECUTION_CONFIG_FLAG_NONE, UINT32_MAX, 0 };
+        QUIC_GLOBAL_EXECUTION_CONFIG Config = { QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE, UINT32_MAX, 0 };
         CxPlatDataPath Datapath(&EmptyUdpCallbacks, nullptr, 0, &Config);
         VERIFY_QUIC_SUCCESS(Datapath.GetInitStatus());
         ASSERT_NE(nullptr, Datapath.Datapath);
     }
     {
-        QUIC_EXECUTION_CONFIG Config = { QUIC_EXECUTION_CONFIG_FLAG_NONE, 0, 0 };
+        QUIC_GLOBAL_EXECUTION_CONFIG Config = { QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE, 0, 0 };
         CxPlatDataPath Datapath(&EmptyUdpCallbacks, nullptr, 0, &Config);
         VERIFY_QUIC_SUCCESS(Datapath.GetInitStatus());
         ASSERT_NE(nullptr, Datapath.Datapath);
     }
     {
-        QUIC_EXECUTION_CONFIG Config = { QUIC_EXECUTION_CONFIG_FLAG_NONE, UINT32_MAX, 1, {0} };
+        QUIC_GLOBAL_EXECUTION_CONFIG Config = { QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE, UINT32_MAX, 1, {0} };
         CxPlatDataPath Datapath(&EmptyUdpCallbacks, nullptr, 0, &Config);
         VERIFY_QUIC_SUCCESS(Datapath.GetInitStatus());
         ASSERT_NE(nullptr, Datapath.Datapath);
     }
     if (UseDuoNic) {
-        QUIC_EXECUTION_CONFIG Config = { QUIC_EXECUTION_CONFIG_FLAG_XDP, 0, 1, {0} };
+        QUIC_GLOBAL_EXECUTION_CONFIG Config = { QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP, 0, 1, {0} };
         CxPlatDataPath Datapath(&EmptyUdpCallbacks, nullptr, 0, &Config);
         VERIFY_QUIC_SUCCESS(Datapath.GetInitStatus());
         ASSERT_NE(nullptr, Datapath.Datapath);
@@ -832,7 +832,7 @@ TEST_P(DataPathTest, UdpData)
 
 TEST_P(DataPathTest, UdpDataPolling)
 {
-    QUIC_EXECUTION_CONFIG Config = { QUIC_EXECUTION_CONFIG_FLAG_NONE, UINT32_MAX, 0 };
+    QUIC_GLOBAL_EXECUTION_CONFIG Config = { QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE, UINT32_MAX, 0 };
     UdpRecvContext RecvContext;
     CxPlatDataPath Datapath(&UdpRecvCallbacks, nullptr, 0, &Config);
     RecvContext.TtlSupported = Datapath.IsSupported(CXPLAT_DATAPATH_FEATURE_TTL);
@@ -1060,7 +1060,7 @@ TEST_P(DataPathTest, MultiBindListener) {
 
 TEST_P(DataPathTest, MultiBindListenerSingleProcessor) {
     UdpRecvContext RecvContext;
-    QUIC_EXECUTION_CONFIG Config = { QUIC_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC, UINT32_MAX, 1, 0 };
+    QUIC_GLOBAL_EXECUTION_CONFIG Config = { QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC, UINT32_MAX, 1, 0 };
     CxPlatDataPath Datapath(&UdpRecvCallbacks, nullptr, 0, &Config);
     RecvContext.TtlSupported = Datapath.IsSupported(CXPLAT_DATAPATH_FEATURE_TTL);
     RecvContext.DscpSupported = Datapath.IsSupported(CXPLAT_DATAPATH_FEATURE_SEND_DSCP);
diff --git a/src/rs/ffi/linux_bindings.rs b/src/rs/ffi/linux_bindings.rs
index 3a7af63ce4..82427880b0 100644
--- a/src/rs/ffi/linux_bindings.rs
+++ b/src/rs/ffi/linux_bindings.rs
@@ -412,40 +412,41 @@ pub const QUIC_DATAGRAM_SEND_STATE_QUIC_DATAGRAM_SEND_ACKNOWLEDGED_SPURIOUS:
     QUIC_DATAGRAM_SEND_STATE = 5;
 pub const QUIC_DATAGRAM_SEND_STATE_QUIC_DATAGRAM_SEND_CANCELED: QUIC_DATAGRAM_SEND_STATE = 6;
 pub type QUIC_DATAGRAM_SEND_STATE = ::std::os::raw::c_uint;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_NONE: QUIC_EXECUTION_CONFIG_FLAGS =
-    0;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_RIO: QUIC_EXECUTION_CONFIG_FLAGS =
-    2;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_XDP: QUIC_EXECUTION_CONFIG_FLAGS =
-    4;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC:
-    QUIC_EXECUTION_CONFIG_FLAGS = 8;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY:
-    QUIC_EXECUTION_CONFIG_FLAGS = 16;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_AFFINITIZE:
-    QUIC_EXECUTION_CONFIG_FLAGS = 32;
-pub type QUIC_EXECUTION_CONFIG_FLAGS = ::std::os::raw::c_uint;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 0;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_RIO:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 2;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 4;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 8;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 16;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_AFFINITIZE:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 32;
+pub type QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = ::std::os::raw::c_uint;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
-pub struct QUIC_EXECUTION_CONFIG {
-    pub Flags: QUIC_EXECUTION_CONFIG_FLAGS,
+pub struct QUIC_GLOBAL_EXECUTION_CONFIG {
+    pub Flags: QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS,
     pub PollingIdleTimeoutUs: u32,
     pub ProcessorCount: u32,
     pub ProcessorList: [u16; 1usize],
 }
 #[allow(clippy::unnecessary_operation, clippy::identity_op)]
 const _: () = {
-    ["Size of QUIC_EXECUTION_CONFIG"][::std::mem::size_of::<QUIC_EXECUTION_CONFIG>() - 16usize];
-    ["Alignment of QUIC_EXECUTION_CONFIG"]
-        [::std::mem::align_of::<QUIC_EXECUTION_CONFIG>() - 4usize];
-    ["Offset of field: QUIC_EXECUTION_CONFIG::Flags"]
-        [::std::mem::offset_of!(QUIC_EXECUTION_CONFIG, Flags) - 0usize];
-    ["Offset of field: QUIC_EXECUTION_CONFIG::PollingIdleTimeoutUs"]
-        [::std::mem::offset_of!(QUIC_EXECUTION_CONFIG, PollingIdleTimeoutUs) - 4usize];
-    ["Offset of field: QUIC_EXECUTION_CONFIG::ProcessorCount"]
-        [::std::mem::offset_of!(QUIC_EXECUTION_CONFIG, ProcessorCount) - 8usize];
-    ["Offset of field: QUIC_EXECUTION_CONFIG::ProcessorList"]
-        [::std::mem::offset_of!(QUIC_EXECUTION_CONFIG, ProcessorList) - 12usize];
+    ["Size of QUIC_GLOBAL_EXECUTION_CONFIG"]
+        [::std::mem::size_of::<QUIC_GLOBAL_EXECUTION_CONFIG>() - 16usize];
+    ["Alignment of QUIC_GLOBAL_EXECUTION_CONFIG"]
+        [::std::mem::align_of::<QUIC_GLOBAL_EXECUTION_CONFIG>() - 4usize];
+    ["Offset of field: QUIC_GLOBAL_EXECUTION_CONFIG::Flags"]
+        [::std::mem::offset_of!(QUIC_GLOBAL_EXECUTION_CONFIG, Flags) - 0usize];
+    ["Offset of field: QUIC_GLOBAL_EXECUTION_CONFIG::PollingIdleTimeoutUs"]
+        [::std::mem::offset_of!(QUIC_GLOBAL_EXECUTION_CONFIG, PollingIdleTimeoutUs) - 4usize];
+    ["Offset of field: QUIC_GLOBAL_EXECUTION_CONFIG::ProcessorCount"]
+        [::std::mem::offset_of!(QUIC_GLOBAL_EXECUTION_CONFIG, ProcessorCount) - 8usize];
+    ["Offset of field: QUIC_GLOBAL_EXECUTION_CONFIG::ProcessorList"]
+        [::std::mem::offset_of!(QUIC_GLOBAL_EXECUTION_CONFIG, ProcessorList) - 12usize];
 };
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
diff --git a/src/rs/ffi/win_bindings.rs b/src/rs/ffi/win_bindings.rs
index 7963fe10b0..c20def9ae0 100644
--- a/src/rs/ffi/win_bindings.rs
+++ b/src/rs/ffi/win_bindings.rs
@@ -411,40 +411,41 @@ pub const QUIC_DATAGRAM_SEND_STATE_QUIC_DATAGRAM_SEND_ACKNOWLEDGED_SPURIOUS:
     QUIC_DATAGRAM_SEND_STATE = 5;
 pub const QUIC_DATAGRAM_SEND_STATE_QUIC_DATAGRAM_SEND_CANCELED: QUIC_DATAGRAM_SEND_STATE = 6;
 pub type QUIC_DATAGRAM_SEND_STATE = ::std::os::raw::c_int;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_NONE: QUIC_EXECUTION_CONFIG_FLAGS =
-    0;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_RIO: QUIC_EXECUTION_CONFIG_FLAGS =
-    2;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_XDP: QUIC_EXECUTION_CONFIG_FLAGS =
-    4;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC:
-    QUIC_EXECUTION_CONFIG_FLAGS = 8;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY:
-    QUIC_EXECUTION_CONFIG_FLAGS = 16;
-pub const QUIC_EXECUTION_CONFIG_FLAGS_QUIC_EXECUTION_CONFIG_FLAG_AFFINITIZE:
-    QUIC_EXECUTION_CONFIG_FLAGS = 32;
-pub type QUIC_EXECUTION_CONFIG_FLAGS = ::std::os::raw::c_int;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 0;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_RIO:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 2;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 4;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NO_IDEAL_PROC:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 8;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_HIGH_PRIORITY:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 16;
+pub const QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS_QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_AFFINITIZE:
+    QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = 32;
+pub type QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS = ::std::os::raw::c_int;
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
-pub struct QUIC_EXECUTION_CONFIG {
-    pub Flags: QUIC_EXECUTION_CONFIG_FLAGS,
+pub struct QUIC_GLOBAL_EXECUTION_CONFIG {
+    pub Flags: QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS,
     pub PollingIdleTimeoutUs: u32,
     pub ProcessorCount: u32,
     pub ProcessorList: [u16; 1usize],
 }
 #[allow(clippy::unnecessary_operation, clippy::identity_op)]
 const _: () = {
-    ["Size of QUIC_EXECUTION_CONFIG"][::std::mem::size_of::<QUIC_EXECUTION_CONFIG>() - 16usize];
-    ["Alignment of QUIC_EXECUTION_CONFIG"]
-        [::std::mem::align_of::<QUIC_EXECUTION_CONFIG>() - 4usize];
-    ["Offset of field: QUIC_EXECUTION_CONFIG::Flags"]
-        [::std::mem::offset_of!(QUIC_EXECUTION_CONFIG, Flags) - 0usize];
-    ["Offset of field: QUIC_EXECUTION_CONFIG::PollingIdleTimeoutUs"]
-        [::std::mem::offset_of!(QUIC_EXECUTION_CONFIG, PollingIdleTimeoutUs) - 4usize];
-    ["Offset of field: QUIC_EXECUTION_CONFIG::ProcessorCount"]
-        [::std::mem::offset_of!(QUIC_EXECUTION_CONFIG, ProcessorCount) - 8usize];
-    ["Offset of field: QUIC_EXECUTION_CONFIG::ProcessorList"]
-        [::std::mem::offset_of!(QUIC_EXECUTION_CONFIG, ProcessorList) - 12usize];
+    ["Size of QUIC_GLOBAL_EXECUTION_CONFIG"]
+        [::std::mem::size_of::<QUIC_GLOBAL_EXECUTION_CONFIG>() - 16usize];
+    ["Alignment of QUIC_GLOBAL_EXECUTION_CONFIG"]
+        [::std::mem::align_of::<QUIC_GLOBAL_EXECUTION_CONFIG>() - 4usize];
+    ["Offset of field: QUIC_GLOBAL_EXECUTION_CONFIG::Flags"]
+        [::std::mem::offset_of!(QUIC_GLOBAL_EXECUTION_CONFIG, Flags) - 0usize];
+    ["Offset of field: QUIC_GLOBAL_EXECUTION_CONFIG::PollingIdleTimeoutUs"]
+        [::std::mem::offset_of!(QUIC_GLOBAL_EXECUTION_CONFIG, PollingIdleTimeoutUs) - 4usize];
+    ["Offset of field: QUIC_GLOBAL_EXECUTION_CONFIG::ProcessorCount"]
+        [::std::mem::offset_of!(QUIC_GLOBAL_EXECUTION_CONFIG, ProcessorCount) - 8usize];
+    ["Offset of field: QUIC_GLOBAL_EXECUTION_CONFIG::ProcessorList"]
+        [::std::mem::offset_of!(QUIC_GLOBAL_EXECUTION_CONFIG, ProcessorList) - 12usize];
 };
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]
diff --git a/src/test/MsQuicTests.h b/src/test/MsQuicTests.h
index 86525643cf..4349171d9b 100644
--- a/src/test/MsQuicTests.h
+++ b/src/test/MsQuicTests.h
@@ -748,7 +748,7 @@ static const GUID QUIC_TEST_DEVICE_INSTANCE =
 
 typedef struct {
     BOOLEAN UseDuoNic;
-    QUIC_EXECUTION_CONFIG Config;
+    QUIC_GLOBAL_EXECUTION_CONFIG Config;
     char CurrentDirectory[MAX_PATH];
 } QUIC_TEST_CONFIGURATION_PARAMS;
 
@@ -1385,7 +1385,7 @@ typedef struct {
 #define IOCTL_QUIC_RUN_TEST_KEY_UPDATE_DURING_HANDSHAKE \
     QUIC_CTL_CODE(130, METHOD_BUFFERED, FILE_WRITE_DATA)
     // int - Family
-    
+
 #define IOCTL_QUIC_RUN_RETRY_MEMORY_LIMIT_CONNECT \
     QUIC_CTL_CODE(131, METHOD_BUFFERED, FILE_WRITE_DATA)
     //int - Family
diff --git a/src/test/bin/quic_gtest.cpp b/src/test/bin/quic_gtest.cpp
index 386a008e63..2b25cc4f4a 100644
--- a/src/test/bin/quic_gtest.cpp
+++ b/src/test/bin/quic_gtest.cpp
@@ -67,7 +67,7 @@ class QuicTestEnvironment : public ::testing::Environment {
                 TRUE, NULL
                 )) != nullptr);
 
-        QUIC_EXECUTION_CONFIG Config = {QUIC_EXECUTION_CONFIG_FLAG_NONE, 0, 0, {0}};
+        QUIC_GLOBAL_EXECUTION_CONFIG Config = {QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE, 0, 0, {0}};
         if (TestingKernelMode) {
             printf("Initializing for Kernel Mode tests\n");
             const char* DriverName;
@@ -95,7 +95,7 @@ class QuicTestEnvironment : public ::testing::Environment {
 
 #if defined(QUIC_API_ENABLE_PREVIEW_FEATURES)
             if (UseDuoNic) {
-                Config.Flags |= QUIC_EXECUTION_CONFIG_FLAG_XDP;
+                Config.Flags |= QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP;
             }
 #endif
             QUIC_TEST_CONFIGURATION_PARAMS Params {
@@ -121,8 +121,8 @@ class QuicTestEnvironment : public ::testing::Environment {
                 Settings.SetQtipEnabled(true);
                 ASSERT_TRUE(QUIC_SUCCEEDED(Settings.SetGlobal()));
             }
-            Config.Flags |= UseDuoNic ? QUIC_EXECUTION_CONFIG_FLAG_XDP : QUIC_EXECUTION_CONFIG_FLAG_NONE;
-            if (Config.Flags != QUIC_EXECUTION_CONFIG_FLAG_NONE) {
+            Config.Flags |= UseDuoNic ? QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP : QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE;
+            if (Config.Flags != QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE) {
                 ASSERT_TRUE(QUIC_SUCCEEDED(
                     MsQuic->SetParam(
                         nullptr,
diff --git a/src/test/bin/winkernel/control.cpp b/src/test/bin/winkernel/control.cpp
index 9b0a9f031f..a6ac648854 100644
--- a/src/test/bin/winkernel/control.cpp
+++ b/src/test/bin/winkernel/control.cpp
@@ -701,8 +701,8 @@ QuicTestCtlEvtIoDeviceControl(
                 STRSAFE_NULL_ON_FAILURE);
 
 #if defined(QUIC_API_ENABLE_PREVIEW_FEATURES)
-        QUIC_EXECUTION_CONFIG Config = Params->TestConfigurationParams.Config;
-        if (Config.Flags != QUIC_EXECUTION_CONFIG_FLAG_NONE) {
+        QUIC_GLOBAL_EXECUTION_CONFIG Config = Params->TestConfigurationParams.Config;
+        if (Config.Flags != QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE) {
             Status =
                 MsQuic->SetParam(
                     nullptr,
diff --git a/src/test/lib/ApiTest.cpp b/src/test/lib/ApiTest.cpp
index 5aa17fec89..0026931b66 100644
--- a/src/test/lib/ApiTest.cpp
+++ b/src/test/lib/ApiTest.cpp
@@ -2596,13 +2596,13 @@ void QuicTestGlobalParam()
                         nullptr));
             }
 
-            uint8_t Data[QUIC_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t) * 4] = {};
+            uint8_t Data[QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t) * 4] = {};
             uint32_t DataLength = sizeof(Data);
-            QUIC_EXECUTION_CONFIG* Config = (QUIC_EXECUTION_CONFIG*)Data;
+            QUIC_GLOBAL_EXECUTION_CONFIG* Config = (QUIC_GLOBAL_EXECUTION_CONFIG*)Data;
             Config->ProcessorCount = 4;
             if (CxPlatProcCount() < Config->ProcessorCount) {
                 Config->ProcessorCount = CxPlatProcCount();
-                DataLength = QUIC_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t) * Config->ProcessorCount;
+                DataLength = QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t) * Config->ProcessorCount;
             }
             for (uint16_t i = 0; i < (uint16_t)Config->ProcessorCount; ++i) {
                 Config->ProcessorList[i] = i;
diff --git a/src/tools/attack/attack.cpp b/src/tools/attack/attack.cpp
index 4d99613f07..5ca413898c 100644
--- a/src/tools/attack/attack.cpp
+++ b/src/tools/attack/attack.cpp
@@ -456,9 +456,9 @@ main(
             UdpUnreachCallback,
         };
         // flag
-        QUIC_EXECUTION_CONFIG_FLAGS Flags = QUIC_EXECUTION_CONFIG_FLAG_XDP;
+        QUIC_GLOBAL_EXECUTION_CONFIG_FLAGS Flags = QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP;
 
-        QUIC_EXECUTION_CONFIG DatapathFlags = {
+        QUIC_GLOBAL_EXECUTION_CONFIG DatapathFlags = {
             Flags,
         };
         CxPlatSystemLoad();
diff --git a/src/tools/spin/spinquic.cpp b/src/tools/spin/spinquic.cpp
index 71140c0f76..035c2e0003 100644
--- a/src/tools/spin/spinquic.cpp
+++ b/src/tools/spin/spinquic.cpp
@@ -28,7 +28,7 @@
     } while (0)
 #define ASSERT_ON_NOT(x) CXPLAT_FRE_ASSERT(x)
 
-QUIC_EXECUTION_CONFIG* ExecConfig = nullptr;
+QUIC_GLOBAL_EXECUTION_CONFIG* ExecConfig = nullptr;
 uint32_t ExecConfigSize = 0;
 
 class FuzzingData {
@@ -1557,12 +1557,12 @@ void start() {
                     1 :
                     1 + GetRandom(CxPlatProcCount() - 1);
             printf("Using %u partitions...\n", ProcCount);
-            ExecConfigSize = QUIC_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t)*ProcCount;
-            ExecConfig = (QUIC_EXECUTION_CONFIG*)malloc(ExecConfigSize);
+            ExecConfigSize = QUIC_GLOBAL_EXECUTION_CONFIG_MIN_SIZE + sizeof(uint16_t)*ProcCount;
+            ExecConfig = (QUIC_GLOBAL_EXECUTION_CONFIG*)malloc(ExecConfigSize);
             if (strncmp(SpinSettings.ServerName, "192.168.1.11", 12) == 0) {
-                ExecConfig->Flags = QUIC_EXECUTION_CONFIG_FLAG_XDP;
+                ExecConfig->Flags = QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_XDP;
             } else {
-                ExecConfig->Flags = QUIC_EXECUTION_CONFIG_FLAG_NONE;
+                ExecConfig->Flags = QUIC_GLOBAL_EXECUTION_CONFIG_FLAG_NONE;
             }
             ExecConfig->PollingIdleTimeoutUs = 0; // TODO - Randomize?
             ExecConfig->ProcessorCount = ProcCount;