Merge branch 'development' of https://github.com/aws-lumberyard-dev/o3de into mnaumov/LYN-4539

Signed-off-by: Mikhail Naumov <mnaumov@amazon.com>

Code/Framework/AzCore/AzCore/Android/APKFileHandler.h

@@ -26,8 +26,8 @@
 #if AZ_ENABLED_VERBOSE_ANDROID_IO_PROFILING
     #include <AzCore/Debug/Profiler.h>
 
-    #define ANDROID_IO_PROFILE_SECTION           AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore)
-    #define ANDROID_IO_PROFILE_SECTION_ARGS(...) AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, __VA_ARGS__)
+    #define ANDROID_IO_PROFILE_SECTION           AZ_PROFILE_FUNCTION(AzCore)
+    #define ANDROID_IO_PROFILE_SECTION_ARGS(...) AZ_PROFILE_SCOPE(AzCore, __VA_ARGS__)
 #else
     #define ANDROID_IO_PROFILE_SECTION
     #define ANDROID_IO_PROFILE_SECTION_ARGS(...)

Code/Framework/AzCore/AzCore/Asset/AssetDataStream.cpp

@@ -27,7 +27,7 @@ namespace AZ::Data
 
     void AssetDataStream::Open(const AZStd::vector<AZ::u8>& data)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ_Assert(!m_isOpen, "Attempting to open the stream when it is already open.");
 
@@ -45,7 +45,7 @@ namespace AZ::Data
 
     void AssetDataStream::Open(AZStd::vector<AZ::u8>&& data)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ_Assert(!m_isOpen, "Attempting to open the stream when it is already open.");
 
@@ -62,7 +62,7 @@ namespace AZ::Data
         AZStd::chrono::milliseconds deadline, AZ::IO::IStreamerTypes::Priority priority,
         OnCompleteCallback loadCallback)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ_Assert(!m_isOpen, "Attempting to open the stream when it is already open.");
         AZ_Assert(!m_curReadRequest, "Queueing an asset stream load while one is still in progress.");
@@ -80,7 +80,7 @@ namespace AZ::Data
             // Set up the callback that will process the asset data once the raw file load is finished.
             auto streamerCallback = [this, loadCallback](AZ::IO::FileRequestHandle fileHandle)
             {
-                AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "AZ::Data::LoadAssetDataStreamCallback %s",
+                AZ_PROFILE_SCOPE(AzCore, "AZ::Data::LoadAssetDataStreamCallback %s",
                     m_filePath.c_str());
 
                 // Get the results 
@@ -183,13 +183,13 @@ namespace AZ::Data
         // the real interval we want to record below won't show up unless this is here.
         /**/
         {
-            AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::AzCore, this + 1, "AssetDataStream: %s", streamName);
-            AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::AzCore, this + 1);
+            AZ_PROFILE_INTERVAL_START(AzCore, this + 1, "AssetDataStream: %s", streamName);
+            AZ_PROFILE_INTERVAL_END(AzCore, this + 1);
         }
         /**/
 
         // Start a timespan marker to track the full load time for the requested asset.
-        AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::AzCore, this, "AssetLoad: %s", streamName);
+        AZ_PROFILE_INTERVAL_START(AzCore, this, "AssetLoad: %s", streamName);
 
         // Lock the allocator to ensure it remains active from Open to Close.
         m_bufferAllocator->LockAllocator();
@@ -216,7 +216,7 @@ namespace AZ::Data
         ClearInternalStateData();
 
         // End the load time timespan marker for this asset.
-        AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::AzCore, this);
+        AZ_PROFILE_INTERVAL_END(AzCore, this);
     }
 
     void AssetDataStream::RequestCancel()
@@ -231,7 +231,7 @@ namespace AZ::Data
 
     void AssetDataStream::Seek(AZ::IO::OffsetType bytes, AZ::IO::GenericStream::SeekMode mode)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZ::IO::OffsetType requestedOffset = 0;
 
         switch (mode)
@@ -261,7 +261,7 @@ namespace AZ::Data
 
     AZ::IO::SizeType AssetDataStream::Read(AZ::IO::SizeType bytes, void* oBuffer)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         if (m_curOffset >= m_loadedSize)
         {
             return 0;

Code/Framework/AzCore/AzCore/Asset/AssetManager.cpp

@@ -163,7 +163,7 @@ namespace AZ
                 else
                 {
 
-                    AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "AZ::Data::LoadAssetJob::Process: %s",
+                    AZ_PROFILE_SCOPE(AzCore, "AZ::Data::LoadAssetJob::Process: %s",
                         asset.GetHint().c_str());
 
                     AZ_ASSET_ATTACH_TO_SCOPE(this);
@@ -198,7 +198,7 @@ namespace AZ
 
                 if(cl_assetLoadDelay > 0)
                 {
-                    AZ_PROFILE_SCOPE_IDLE(AZ::Debug::ProfileCategory::AzCore, "LoadData suspended");
+                    AZ_PROFILE_SCOPE(AzCore, "LoadData suspended");
                     AZStd::this_thread::sleep_for(AZStd::chrono::milliseconds(cl_assetLoadDelay));
                 }
 
@@ -314,7 +314,7 @@ namespace AZ
         protected:
             void Wait()
             {
-                AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "WaitForAsset - %s", m_assetData.GetHint().c_str());
+                AZ_PROFILE_SCOPE(AzCore, "WaitForAsset - %s", m_assetData.GetHint().c_str());
 
                 // Continue to loop until the load completes.  (Most of the time in the loop will be spent in a thread-blocking state)
                 while (!m_loadCompleted)
@@ -344,7 +344,7 @@ namespace AZ
 
             void Finish()
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                AZ_PROFILE_FUNCTION(AzCore);
                 m_loadCompleted = true;
                 m_waitEvent.release();
             }
@@ -403,7 +403,7 @@ namespace AZ
             void SaveAsset()
             {
                 auto asset = m_asset.GetStrongReference();
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                AZ_PROFILE_FUNCTION(AzCore);
                 bool isSaved = false;
                 AssetStreamInfo saveInfo = m_owner->GetSaveStreamInfoForAsset(asset.GetId(), asset.GetType());
                 if (saveInfo.IsValid())
@@ -565,7 +565,7 @@ namespace AZ
         //=========================================================================
         void AssetManager::DispatchEvents()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             AssetManagerNotificationBus::Broadcast(&AssetManagerNotificationBus::Events::OnAssetEventsDispatchBegin);
             AssetBus::ExecuteQueuedEvents();
             AssetManagerNotificationBus::Broadcast(&AssetManagerNotificationBus::Events::OnAssetEventsDispatchEnd);
@@ -937,14 +937,14 @@ namespace AZ
         Asset<AssetData> AssetManager::GetAssetInternal(const AssetId& assetId, [[maybe_unused]] const AssetType& assetType,
             AssetLoadBehavior assetReferenceLoadBehavior, const AssetLoadParameters& loadParams, AssetInfo assetInfo /*= () */, bool signalLoaded /*= false */)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             AZ_Error("AssetDatabase", assetId.IsValid(), "GetAsset called with invalid asset Id.");
             AZ_Error("AssetDatabase", !assetType.IsNull(), "GetAsset called with invalid asset type.");
             bool assetMissing = false;
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: GetAssetInfo");
+                AZ_PROFILE_SCOPE(AzCore, "GetAsset: GetAssetInfo");
 
                 // Attempt to look up asset info from catalog
                 // This is so that when assetId is a legacy id, we're operating on the canonical id anyway
@@ -974,7 +974,7 @@ namespace AZ
                 }
             }
 
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "GetAsset: %s", assetInfo.m_relativePath.c_str());
+            AZ_PROFILE_SCOPE(AzCore, "GetAsset: %s", assetInfo.m_relativePath.c_str());
             AZ_ASSET_NAMED_SCOPE("GetAsset: %s", assetInfo.m_relativePath.c_str());
 
             AZStd::shared_ptr<AssetDataStream> dataStream;
@@ -992,7 +992,7 @@ namespace AZ
 
                 // check if asset already exists
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: FindAsset");
+                    AZ_PROFILE_SCOPE(AzCore, "GetAsset: FindAsset");
 
                     AssetMap::iterator it = m_assets.find(assetInfo.m_assetId);
                     if (it != m_assets.end())
@@ -1007,7 +1007,7 @@ namespace AZ
                 }
 
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: FindAssetHandler");
+                    AZ_PROFILE_SCOPE(AzCore, "GetAsset: FindAssetHandler");
 
                     // find the asset type handler
                     AssetHandlerMap::iterator handlerIt = m_handlers.find(assetInfo.m_assetType);
@@ -1019,7 +1019,7 @@ namespace AZ
                         handler = handlerIt->second;
                         if (isNewEntry)
                         {
-                            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: CreateAsset");
+                            AZ_PROFILE_SCOPE(AzCore, "GetAsset: CreateAsset");
 
                             assetData = handler->CreateAsset(assetInfo.m_assetId, assetInfo.m_assetType);
                             if (assetData)
@@ -1043,7 +1043,7 @@ namespace AZ
                 {
                     if (isNewEntry && assetData->IsRegisterReadonlyAndShareable())
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "GetAsset: RegisterAsset");
+                        AZ_PROFILE_SCOPE(AzCore, "GetAsset: RegisterAsset");
                         m_assets.insert(AZStd::make_pair(assetInfo.m_assetId, assetData));
                     }
                     if (assetData->GetStatus() == AssetData::AssetStatus::NotLoaded)
@@ -1596,7 +1596,7 @@ namespace AZ
             const AZ::Data::AssetStreamInfo& streamInfo, bool isReload,
             AssetHandler* handler, const AssetLoadParameters& loadParams, bool signalLoaded)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             // Set up the callback that will process the asset data once the raw file load is finished.
             // The callback is declared as mutable so that we can clear weakAsset within the callback.  The refcount in weakAsset
@@ -1613,7 +1613,7 @@ namespace AZ
 
                 if (loadingAsset)
                 {
-                    AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "AZ::Data::LoadAssetStreamerCallback %s",
+                    AZ_PROFILE_SCOPE(AzCore, "AZ::Data::LoadAssetStreamerCallback %s",
                         loadingAsset.GetHint().c_str());
                     {
                         AZStd::scoped_lock<AZStd::recursive_mutex> assetLock(m_assetMutex);
@@ -1788,7 +1788,7 @@ namespace AZ
         //=========================================================================
         void AssetManager::RegisterAssetLoading(const Asset<AssetData>& asset)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             AssetData* data = asset.Get();
             if (data)
@@ -1803,7 +1803,7 @@ namespace AZ
         //=========================================================================
         void AssetManager::UnregisterAssetLoading([[maybe_unused]] const Asset<AssetData>& asset)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
         }
 
         //=========================================================================
@@ -2050,7 +2050,7 @@ namespace AZ
             AZStd::shared_ptr<AssetDataStream> stream,
             const AssetFilterCB& assetLoadFilterCB)
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "AssetHandler::LoadAssetData - %s", asset.GetHint().c_str());
+            AZ_PROFILE_SCOPE(AzCore, "AssetHandler::LoadAssetData - %s", asset.GetHint().c_str());
 
 #ifdef AZ_ENABLE_TRACING
             auto start = AZStd::chrono::system_clock::now();
@@ -2119,7 +2119,7 @@ namespace AZ
         void AssetManager::PostLoad(AZ::Data::Asset<AZ::Data::AssetData>& asset, bool loadSucceeded,
                                     bool isReload, AZ::Data::AssetHandler* assetHandler)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             if (!assetHandler)
             {
                 assetHandler = GetHandler(asset.GetType());

Code/Framework/AzCore/AzCore/AzCoreModule.cpp

@@ -19,7 +19,6 @@
 #include <AzCore/Slice/SliceComponent.h>
 #include <AzCore/Slice/SliceSystemComponent.h>
 #include <AzCore/Slice/SliceMetadataInfoComponent.h>
-#include <AzCore/Statistics/StatisticalProfilerProxySystemComponent.h>
 #include <AzCore/UserSettings/UserSettingsComponent.h>
 #include <AzCore/Time/TimeSystemComponent.h>
 #include <AzCore/Console/LoggerSystemComponent.h>
@@ -45,9 +44,6 @@ namespace AZ
             LoggerSystemComponent::CreateDescriptor(),
             EventSchedulerSystemComponent::CreateDescriptor(),
 
-#if !defined(_RELEASE)
-            Statistics::StatisticalProfilerProxySystemComponent::CreateDescriptor(),
-#endif // #if !defined(_RELEASE)
 #if !defined(AZCORE_EXCLUDE_LUA)
             ScriptSystemComponent::CreateDescriptor(),
 #endif // #if !defined(AZCORE_EXCLUDE_LUA)
@@ -61,10 +57,6 @@ namespace AZ
             azrtti_typeid<TimeSystemComponent>(),
             azrtti_typeid<LoggerSystemComponent>(),
             azrtti_typeid<EventSchedulerSystemComponent>(),
-
-#if !defined(_RELEASE)
-            azrtti_typeid<AZ::Statistics::StatisticalProfilerProxySystemComponent>(),
-#endif // #if !defined(_RELEASE)
         };
     }
 }

Code/Framework/AzCore/AzCore/Component/ComponentApplication.cpp

@@ -1394,8 +1394,7 @@ namespace AZ
     void ComponentApplication::Tick(float deltaOverride /*= -1.f*/)
     {
         {
-            AZ_PROFILE_TIMER("System", "Component application simulation tick function");
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_SCOPE(System, "Component application simulation tick");
 
             AZStd::chrono::system_clock::time_point now = AZStd::chrono::system_clock::now();
 
@@ -1408,12 +1407,12 @@ namespace AZ
             }
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "ComponentApplication::Tick:ExecuteQueuedEvents");
+                AZ_PROFILE_SCOPE(AzCore, "ComponentApplication::Tick:ExecuteQueuedEvents");
                 TickBus::ExecuteQueuedEvents();
             }
             m_currentTime = now;
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "ComponentApplication::Tick:OnTick");
+                AZ_PROFILE_SCOPE(AzCore, "ComponentApplication::Tick:OnTick");
                 EBUS_EVENT(TickBus, OnTick, m_deltaTime, ScriptTimePoint(now));
             }
         }
@@ -1428,8 +1427,7 @@ namespace AZ
     //=========================================================================
     void ComponentApplication::TickSystem()
     {
-        AZ_PROFILE_TIMER("System", "Component application system tick function");
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_SCOPE(System, "Component application tick");
 
         SystemTickBus::ExecuteQueuedEvents();
         EBUS_EVENT(SystemTickBus, OnSystemTick);

Code/Framework/AzCore/AzCore/Component/ComponentApplication.h

@@ -11,7 +11,6 @@
 #include <AzCore/Component/Component.h>
 #include <AzCore/Component/Entity.h>
 #include <AzCore/Component/TickBus.h>
-#include <AzCore/Debug/ProfileModuleInit.h>
 #include <AzCore/Memory/AllocationRecords.h>
 #include <AzCore/Memory/OSAllocator.h>
 #include <AzCore/Module/DynamicModuleHandle.h>

Code/Framework/AzCore/AzCore/Component/Entity.cpp

@@ -189,7 +189,7 @@ namespace AZ
 
     void Entity::Activate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ_Assert(m_state == State::Init, "Entity should be in Init state to be Activated!");
 
@@ -226,7 +226,7 @@ namespace AZ
 
     void Entity::Deactivate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZ::ComponentApplicationRequests* componentApplication = AZ::Interface<AZ::ComponentApplicationRequests>::Get();
         if (componentApplication != nullptr)
@@ -1034,7 +1034,7 @@ namespace AZ
 
     Entity::DependencySortOutcome Entity::DependencySort(ComponentArrayType& inOutComponents)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         using DependencySortInternal::ComponentInfo;
         using DependencySortInternal::InvalidEntry;

Code/Framework/AzCore/AzCore/Component/EntityUtils.cpp

@@ -40,7 +40,7 @@ namespace AZ
         //=========================================================================
         void EnumerateEntityIds(const void* classPtr, const Uuid& classUuid, const EntityIdVisitor& visitor, SerializeContext* context)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             if (!context)
             {

Code/Framework/AzCore/AzCore/Component/EntityUtils.h

@@ -54,7 +54,7 @@ namespace AZ
         template<class T>
         unsigned int ReplaceEntityRefs(T* classPtr, const EntityIdMapper& mapper, SerializeContext* context = nullptr)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             auto idMapper = [&mapper](const EntityId& originalId, bool isEntityId, const IdUtils::Remapper<EntityId>::IdGenerator&) -> EntityId
             {
                 return mapper(originalId, isEntityId);
@@ -83,7 +83,7 @@ namespace AZ
         template<class T>
         unsigned int ReplaceEntityIds(T* classPtr, const EntityIdMapper& mapper, SerializeContext* context = nullptr)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             auto idMapper = [&mapper](const EntityId& originalId, bool isEntityId, const IdUtils::Remapper<EntityId>::IdGenerator&) -> EntityId
             {
                 return mapper(originalId, isEntityId);
@@ -97,7 +97,7 @@ namespace AZ
         template<class T>
         unsigned int ReplaceEntityIdsAndEntityRefs(T* classPtr, const EntityIdMapper& mapper, SerializeContext* context = nullptr)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             auto idMapper = [&mapper](const EntityId& originalId, bool isEntityId, const IdUtils::Remapper<EntityId>::IdGenerator&) -> EntityId
             {
                 return mapper(originalId, isEntityId);

Code/Framework/AzCore/AzCore/Console/Console.cpp

@@ -174,15 +174,31 @@ namespace AZ
         }
     }
 
-    bool Console::HasCommand(const char* command)
+    bool Console::ExecuteDeferredConsoleCommands()
+    {
+        auto DeferredCommandCallable = [this](const DeferredCommand& deferredCommand)
+        {
+            return this->DispatchCommand(deferredCommand.m_command, deferredCommand.m_arguments, deferredCommand.m_silentMode,
+                deferredCommand.m_invokedFrom, deferredCommand.m_requiredSet, deferredCommand.m_requiredClear);
+        };
+        // Attempt to invoke the deferred command and remove it from the queue if successful
+        return AZStd::erase_if(m_deferredCommands, DeferredCommandCallable) != 0;
+    }
+
+    void Console::ClearDeferredConsoleCommands()
+    {
+        m_deferredCommands = {};
+    }
+
+    bool Console::HasCommand(AZStd::string_view command)
     {
         return FindCommand(command) != nullptr;
     }
 
-    ConsoleFunctorBase* Console::FindCommand(const char* command)
+    ConsoleFunctorBase* Console::FindCommand(AZStd::string_view command)
     {
         CVarFixedString lowerName(command);
-        AZStd::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), [](char value) { return std::tolower(value); });
+        AZStd::to_lower(lowerName.begin(), lowerName.end());
 
         CommandMap::iterator iter = m_commands.find(lowerName);
         if (iter != m_commands.end())
@@ -200,11 +216,9 @@ namespace AZ
         return nullptr;
     }
 
-    AZStd::string Console::AutoCompleteCommand(const char* command, AZStd::vector<AZStd::string>* matches)
+    AZStd::string Console::AutoCompleteCommand(AZStd::string_view command, AZStd::vector<AZStd::string>* matches)
     {
-        const size_t commandLength = strlen(command);
-
-        if (commandLength <= 0)
+        if (command.empty())
         {
             return command;
         }
@@ -219,7 +233,7 @@ namespace AZ
                 continue;
             }
 
-            if (StringFunc::Equal(curr->m_name, command, false, commandLength))
+            if (StringFunc::StartsWith(curr->m_name, command, false))
             {
                 AZLOG_INFO("- %s : %s\n", curr->m_name, curr->m_desc);
                 commandSubset.push_back(curr->m_name);
@@ -270,7 +284,7 @@ namespace AZ
         }
 
         CVarFixedString lowerName = functor->GetName();
-        AZStd::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), [](char value) { return std::tolower(value); });
+        AZStd::to_lower(lowerName.begin(), lowerName.end());
         CommandMap::iterator iter = m_commands.find(lowerName);
         if (iter != m_commands.end())
         {
@@ -313,7 +327,7 @@ namespace AZ
         }
 
         CVarFixedString lowerName = functor->GetName();
-        AZStd::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), [](char value) { return std::tolower(value); });
+        AZStd::to_lower(lowerName.begin(), lowerName.end());
         CommandMap::iterator iter = m_commands.find(lowerName);
         if (iter != m_commands.end())
         {
@@ -389,7 +403,7 @@ namespace AZ
         ConsoleFunctorFlags flags = ConsoleFunctorFlags::Null;
 
         CVarFixedString lowerName(command);
-        AZStd::transform(lowerName.begin(), lowerName.end(), lowerName.begin(), [](char value) { return std::tolower(value); });
+        AZStd::to_lower(lowerName.begin(), lowerName.end());
 
         CommandMap::iterator iter = m_commands.find(lowerName);
         if (iter != m_commands.end())
@@ -498,7 +512,8 @@ namespace AZ
 
             AZ::IO::PathView consoleRootCommandKey{ IConsole::ConsoleRootCommandKey, AZ::IO::PosixPathSeparator };
             AZ::IO::PathView inputKey{ path, AZ::IO::PosixPathSeparator };
-            if (inputKey.IsRelativeTo(consoleRootCommandKey))
+            // The ConsoleRootComamndKey is not a command itself so strictly children keys are being examined
+            if (inputKey.IsRelativeTo(consoleRootCommandKey) && inputKey != consoleRootCommandKey)
             {
                 FixedValueString command = inputKey.LexicallyRelative(consoleRootCommandKey).Native();
                 ConsoleCommandContainer commandArgs;
@@ -560,7 +575,24 @@ namespace AZ
                     commandTrace += commandArg;
                 }
 
-                m_console.PerformCommand(command, commandArgs, ConsoleSilentMode::NotSilent, ConsoleInvokedFrom::AzConsole, ConsoleFunctorFlags::Null, ConsoleFunctorFlags::Null);
+                if (!m_console.PerformCommand(command, commandArgs, ConsoleSilentMode::NotSilent,
+                    ConsoleInvokedFrom::AzConsole, ConsoleFunctorFlags::Null, ConsoleFunctorFlags::Null))
+                {
+                    // If the command could not be dispatched at this time add it to the
+                    // deferred commands queue
+                    using DeferredCommand = Console::DeferredCommand;
+                    DeferredCommand deferredCommand
+                    {
+                        AZStd::string_view{command},
+                        DeferredCommand::DeferredArguments{commandArgs.begin(), commandArgs.end()},
+                        ConsoleSilentMode::NotSilent,
+                        ConsoleInvokedFrom::AzConsole,
+                        ConsoleFunctorFlags::Null,
+                        ConsoleFunctorFlags::Null
+                    };
+
+                    m_console.m_deferredCommands.emplace_back(AZStd::move(deferredCommand));
+                }
             }
         }
 

Code/Framework/AzCore/AzCore/Console/Console.h

@@ -60,9 +60,13 @@ namespace AZ
         ) override;
         void ExecuteConfigFile(AZStd::string_view configFileName) override;
         void ExecuteCommandLine(const AZ::CommandLine& commandLine) override;
-        bool HasCommand(const char* command) override;
-        ConsoleFunctorBase* FindCommand(const char* command) override;
-        AZStd::string AutoCompleteCommand(const char* command, AZStd::vector<AZStd::string>* matches = nullptr) override;
+        bool ExecuteDeferredConsoleCommands() override;
+
+        void ClearDeferredConsoleCommands() override;
+
+        bool HasCommand(AZStd::string_view command) override;
+        ConsoleFunctorBase* FindCommand(AZStd::string_view command) override;
+        AZStd::string AutoCompleteCommand(AZStd::string_view command, AZStd::vector<AZStd::string>* matches = nullptr) override;
         void VisitRegisteredFunctors(const FunctorVisitor& visitor) override;
         void RegisterFunctor(ConsoleFunctorBase* functor) override;
         void UnregisterFunctor(ConsoleFunctorBase* functor) override;
@@ -98,7 +102,20 @@ namespace AZ
         using CommandMap = AZStd::unordered_map<CVarFixedString, AZStd::vector<ConsoleFunctorBase*>>;
         CommandMap m_commands;
         AZ::SettingsRegistryInterface::NotifyEventHandler m_consoleCommandKeyHandler;
+        struct DeferredCommand
+        {
+            using DeferredArguments = AZStd::vector<AZStd::string>;
+            AZStd::string m_command;
+            DeferredArguments m_arguments;
+            ConsoleSilentMode m_silentMode;
+            ConsoleInvokedFrom m_invokedFrom;
+            ConsoleFunctorFlags m_requiredSet;
+            ConsoleFunctorFlags m_requiredClear;
+        };
+        using DeferredCommandQueue = AZStd::deque<DeferredCommand>;
+        DeferredCommandQueue m_deferredCommands;
 
+        friend struct ConsoleCommandKeyNotificationHandler;
         friend class ConsoleFunctorBase;
     };
 }

Code/Framework/AzCore/AzCore/Console/IConsole.h

@@ -94,22 +94,30 @@ namespace AZ
         //! @param commandLine the concatenated command-line string to execute
         virtual void ExecuteCommandLine(const AZ::CommandLine& commandLine) = 0;
 
+        //! Attempts to invoke a "deferred console command", which is a console command
+        //! that has failed to execute previously due to the command not being registered yet.
+        //! @return boolean true if any deferred console commands have executed, false otherwise
+        virtual bool ExecuteDeferredConsoleCommands() = 0;
+
+        //! Clear out any deferred console commands queue
+        virtual void ClearDeferredConsoleCommands() = 0;
+
         //! HasCommand is used to determine if the console knows about a command.
         //! @param command the command we are checking for
         //! @return boolean true on if the command is registered, false otherwise
-        virtual bool HasCommand(const char* command) = 0;
+        virtual bool HasCommand(AZStd::string_view command) = 0;
 
         //! FindCommand finds the console command with the specified console string.
         //! @param command the command that is being searched for
         //! @return non-null pointer to the console command if found
-        virtual ConsoleFunctorBase* FindCommand(const char* command) = 0;
+        virtual ConsoleFunctorBase* FindCommand(AZStd::string_view command) = 0;
 
         //! Finds all commands where the input command is a prefix and returns
         //! the longest matching substring prefix the results have in common.
         //! @param command The prefix string to find all matching commands for.
         //! @param matches The list of all commands that match the input prefix.
         //! @return The longest matching substring prefix the results have in common.
-        virtual AZStd::string AutoCompleteCommand(const char* command,
+        virtual AZStd::string AutoCompleteCommand(AZStd::string_view command,
                                                   AZStd::vector<AZStd::string>* matches = nullptr) = 0;
 
         //! Retrieves the value of the requested cvar.
@@ -117,7 +125,7 @@ namespace AZ
         //! @param outValue reference to the instance to write the current cvar value to
         //! @return GetValueResult::Success if the operation succeeded, or an error result if the operation failed
         template<typename RETURN_TYPE>
-        GetValueResult GetCvarValue(const char* command, RETURN_TYPE& outValue);
+        GetValueResult GetCvarValue(AZStd::string_view command, RETURN_TYPE& outValue);
 
         //! Visits all registered console functors.
         //! @param visitor the instance to visit all functors with
@@ -176,7 +184,7 @@ namespace AZ
     }
 
     template<typename RETURN_TYPE>
-    inline GetValueResult IConsole::GetCvarValue(const char* command, RETURN_TYPE& outValue)
+    inline GetValueResult IConsole::GetCvarValue(AZStd::string_view command, RETURN_TYPE& outValue)
     {
         ConsoleFunctorBase* cvarFunctor = FindCommand(command);
         if (cvarFunctor == nullptr)

Code/Framework/AzCore/AzCore/Debug/EventTrace.h

@@ -38,17 +38,6 @@ namespace AZ
     }
 }
 
-#ifdef AZ_PROFILE_TELEMETRY
-#   define AZ_TRACE_METHOD_NAME_CATEGORY(name, category) AZ::Debug::EventTrace::ScopedSlice AZ_JOIN(ScopedSlice__, __LINE__)(name, category);
-#   define AZ_TRACE_METHOD_NAME(name) \
-        AZ_TRACE_METHOD_NAME_CATEGORY(name, "") \
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzTrace, name)
-
-#   define AZ_TRACE_METHOD() \
-        AZ_TRACE_METHOD_NAME_CATEGORY(AZ_FUNCTION_SIGNATURE, "") \
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzTrace)
-#else
-#   define AZ_TRACE_METHOD_NAME_CATEGORY(name, category)
-#   define AZ_TRACE_METHOD_NAME(name) AZ_TRACE_METHOD_NAME_CATEGORY(name, "")
-#   define AZ_TRACE_METHOD() AZ_TRACE_METHOD_NAME(AZ_FUNCTION_SIGNATURE)
-#endif
+#define AZ_TRACE_METHOD_NAME_CATEGORY(name, category)
+#define AZ_TRACE_METHOD_NAME(name) AZ_TRACE_METHOD_NAME_CATEGORY(name, "")
+#define AZ_TRACE_METHOD() AZ_TRACE_METHOD_NAME(AZ_FUNCTION_SIGNATURE)

Code/Framework/AzCore/AzCore/Debug/IEventLogger.h

@@ -13,6 +13,7 @@
 #include <AzCore/RTTI/TypeInfoSimple.h>
 #include <AzCore/std/limits.h>
 #include <AzCore/std/string/string_view.h>
+#include <AzCore/Casting/numeric_cast.h>
 
 namespace AZ::Debug
 {

Code/Framework/AzCore/AzCore/Debug/MemoryProfiler.h

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) Contributors to the Open 3D Engine Project.
+ * For complete copyright and license terms please see the LICENSE at the root of this distribution.
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR MIT
+ *
+ */
+#pragma once
+
+#ifndef AZ_PROFILE_MEMORY_ALLOC
+// No other profiler has defined the performance markers AZ_PROFILE_MEMORY_ALLOC (and friends), fall back to a Driller implementation (currently empty)
+#   define AZ_PROFILE_MEMORY_ALLOC(category, address, size, context)
+#   define AZ_PROFILE_MEMORY_ALLOC_EX(category, filename, lineNumber, address, size, context)
+#   define AZ_PROFILE_MEMORY_FREE(category, address)
+#   define AZ_PROFILE_MEMORY_FREE_EX(category, filename, lineNumber, address)
+#endif

Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.cpp

@@ -1,53 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#include <AzCore/Debug/ProfileModuleInit.h>
-
-#ifdef AZ_PROFILE_TELEMETRY
-#   include <RADTelemetry/ProfileTelemetryBus.h>
-    // Define the per-module RAD Telemetry instance pointer
-    struct tm_api;
-    tm_api* g_radTmApi;
-#endif
-
-
-namespace AZ
-{
-    namespace Debug
-    {
-        void ProfileModuleInit()
-        {
-#if defined(AZ_PROFILE_TELEMETRY)
-            {
-                if (!g_radTmApi)
-                {
-                    using namespace RADTelemetry;
-                    ProfileTelemetryRequestBus::BroadcastResult(g_radTmApi, &ProfileTelemetryRequests::GetApiInstance);
-                }
-            }
-#endif
-            // Add additional per-DLL required profiler initialization here
-        }
-
-
-        ProfileModuleInitializer::ProfileModuleInitializer()
-        {
-            ProfilerNotificationBus::Handler::BusConnect();
-        }
-
-        ProfileModuleInitializer::~ProfileModuleInitializer()
-        {
-            ProfilerNotificationBus::Handler::BusDisconnect();
-        }
-
-        void ProfileModuleInitializer::OnProfileSystemInitialized()
-        {
-            ProfileModuleInit();
-        }
-    }
-}

Code/Framework/AzCore/AzCore/Debug/ProfileModuleInit.h

@@ -1,36 +0,0 @@
-/*
- * Copyright (c) Contributors to the Open 3D Engine Project.
- * For complete copyright and license terms please see the LICENSE at the root of this distribution.
- *
- * SPDX-License-Identifier: Apache-2.0 OR MIT
- *
- */
-
-#pragma once
-
-#include <AzCore/Debug/ProfilerBus.h>
-
-namespace AZ
-{
-    namespace Debug
-    {
-        //! Perform any required per-module initialization of the current profiler
-        void ProfileModuleInit();
-
-
-        /*!
-        * ProfileModuleInitializer
-        * Helper class that calls ProfileModuleInit when OnProfileSystemInitialized is fired.
-        */
-        class ProfileModuleInitializer
-            : private AZ::Debug::ProfilerNotificationBus::Handler
-        {
-        public:
-            ProfileModuleInitializer();
-            ~ProfileModuleInitializer() override;
-
-        private:
-            void OnProfileSystemInitialized() override;
-        };
-    }
-}

Code/Framework/AzCore/AzCore/Debug/Profiler.cpp

@@ -20,6 +20,12 @@
 
 namespace AZ
 {
+    uint32_t ProfileScope::GetSystemID(const char* system)
+    {
+        // TODO: stable ids for registered budgets
+        return AZ::Crc32(system);
+    }
+
     namespace Debug
     {
         //////////////////////////////////////////////////////////////////////////
@@ -537,6 +543,7 @@ namespace AZ
         void ProfilerRegister::TimerStart(ProfilerSection* section)
         {
             ProfilerRegister* reg = this;
+
             if (reg->m_isActive)
             {
                 section->m_register = reg;

Code/Framework/AzCore/AzCore/Debug/Profiler.h

@@ -5,310 +5,44 @@
  * SPDX-License-Identifier: Apache-2.0 OR MIT
  *
  */
-#ifndef AZCORE_PROFILER_H
-#define AZCORE_PROFILER_H 1
+#pragma once
 
 #include <AzCore/std/chrono/chrono.h>
 #include <AzCore/std/function/function_fwd.h>
 
-namespace AZ
-{
-    namespace Debug
-    {
-        using ProfileCategoryPrimitiveType = AZ::u64;
-
-        /**
-        * Profiling categories consumed by AZ_PROFILE_FUNCTION and AZ_PROFILE_SCOPE variants for profile filtering
-        */
-        enum class ProfileCategory : ProfileCategoryPrimitiveType
-        {
-            // These initial categories match up with the legacy EProfiledSubsystem categories
-            Any = 0,
-            Renderer,
-            ThreeDEngine,
-            Particle,
-            AI,
-            Animation,
-            Movie,
-            Entity,
-            Font,
-            Network,
-            Physics,
-            Script,
-            ScriptCFunc,
-            Audio,
-            Editor,
-            System,
-            Action,
-            Game,
-            Input,
-            Sync,
-
-            // Legacy network traffic categories
-            LegacyNetworkTrafficReserved,
-            LegacyDeviceReserved,
-
-            // must match EProfiledSubsystem::PROFILE_LAST_SUBSYSTEM
-            LegacyLast,
-
-            // Bulk category via AZ_TRACE_METHOD
-            AzTrace,
-
-            AzCore,
-            AzRender,
-            AzFramework,
-            AzToolsFramework,
-            ScriptCanvas,
-            LegacyTerrain,
-            Terrain,
-            Cloth,
-            // Add new major categories here (and add names to the parallel position in ProfileCategoryNames) - these categories are enabled by default
-
-            FirstDetailedCategory,
-            RendererDetailed = FirstDetailedCategory,
-            ThreeDEngineDetailed,
-            JobManagerDetailed,
-
-            AzRenderDetailed,
-            ClothDetailed,
-            // Add new detailed categories here (and add names to the parallel position in ProfileCategoryNames) -- these categories are disabled by default
-            
-            // Internal reserved categories, not for use with performance events
-            FirstReservedCategory,
-            MemoryReserved = FirstReservedCategory,
-            Global,
-
-            // Must be last
-            Count
-        };
-        static_assert(static_cast<size_t>(ProfileCategory::Count) < (sizeof(ProfileCategoryPrimitiveType) * 8), "The number of profile categories must not exceed the number of bits in ProfileCategoryPrimitiveType");
-
-        /**
-        * Parallel array to ProfileCategory as string category names to be used as Driller category names or for debug purposes
-        */
-        static const char * ProfileCategoryNames[] =
-        {
-            "Any",
-            "Renderer",
-            "3DEngine",
-            "Particle",
-            "AI",
-            "Animation",
-            "Movie",
-            "Entity",
-            "Font",
-            "Network",
-            "Physics",
-            "Script",
-            "ScriptCFunc",
-            "Audio",
-            "Editor",
-            "System",
-            "Action",
-            "Game",
-            "Input",
-            "Sync",
-
-            "LegacyNetworkTrafficReserved",
-            "LegacyDeviceReserved",
-
-            "LegacyLast",
-
-            "AzTrace",
-            "AzCore",
-            "AzRender",
-            "AzFramework",
-            "AzToolsFramework",
-            "ScriptCanvas",
-            "LegacyTerrain",
-            "Terrain",
-            "Cloth",
-
-            "RendererDetailed",
-            "3DEngineDetailed",
-            "JobManagerDetailed",
-            "AzRenderDetailed",
-            "ClothDetailed",
-
-            "MemoryReserved",
-            "Global"
-        };
-        static_assert(AZ_ARRAY_SIZE(ProfileCategoryNames) == static_cast<size_t>(ProfileCategory::Count), "ProfileCategory and ProfileCategoryNames size mismatch");
-    }
-}
-
-// Must be included below ProfileCategory 
-#ifdef AZ_PROFILE_TELEMETRY
-#   include <RADTelemetry/ProfileTelemetry.h>
+#ifdef USE_PIX
+#include <AzCore/PlatformIncl.h>
+#include <WinPixEventRuntime/pix3.h>
 #endif
 
 #if defined(AZ_PROFILER_MACRO_DISABLE) // by default we never disable the profiler registers as their overhead should be minimal, you can still do that for your code though.
-#   define AZ_PROFILE_TIMER(...)
-#   define AZ_PROFILE_TIMER_END(_SectionVariableName)
-#   define AZ_PROFILE_VALUE_SET(...)
-#   define AZ_PROFILE_VALUE_ADD(...)
-#   define AZ_PROFILE_VALUE_SET_NAMED(...)
-#   define AZ_PROFILE_VALUE_ADD_NAMED(...)
+#   define AZ_PROFILE_SCOPE(...)
+#   define AZ_PROFILE_FUNCTION(...)
+#   define AZ_PROFILE_BEGIN(...)
+#   define AZ_PROFILE_END(...)
 #else
-/// Implementation when we have only 1 param system name
-#   define AZ_PROFILE_TIMER_1(_1)     AZ_PROFILE_TIMER_2(_1, nullptr)
-/// Implementation when we have 2 params (_1 system name and _2 is name of the "section"/register/profiled section - used for debug)
-#   define AZ_PROFILE_TIMER_2(_1, _2)  AZ_PROFILE_TIMER_3(_1, _2, AZ_JOIN(azProfileSection, __LINE__))
-/// Implementation when we have all 3 params (system name, section/register name, section variable name)
-#   define AZ_PROFILE_TIMER_3(_1, _2, _3)                                                                                                                     \
-    AZ::Debug::ProfilerSection _3;                                                                                                                            \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                  \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                      \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::TimerCreateAndStart(_1, _2, &_3, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                   \
-        } else {                                                                                                                                              \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register->TimerStart(&_3);                                                                                 \
-        }                                                                                                                                                     \
-    }
-
 /**
  * Macro to declare a profile section for the current scope { }.
- * format is: AZ_PROFILE_TIMER(const char* systemName, const char* sectionDescription = nullptr , optional sectionName )
- * \param _1 is required and it's 'const char*' of the system name of which system this scope/register belongs to.
- * \param _2 is optional and it's 'const char*' with a name for the "section"/register/profiled section - used as description. If not provided a "Anonymous" will be set.
- * \param _3 is optional unique name for a section C++ variable (so you can stop the SCOPE as you wish). If not provided a default unique name is created.
+ * format is: AZ_PROFILE_SCOPE(categoryName, const char* formatStr, ...)
  */
-#   define AZ_PROFILE_TIMER(...)        AZ_MACRO_SPECIALIZE(AZ_PROFILE_TIMER_, AZ_VA_NUM_ARGS(__VA_ARGS__), (__VA_ARGS__))
-
-// Optional (USE ONLY IN EXTREME CASES!!!) scope end command for named sections, so you stop the profiler register timing before it goes out of scope.
-#   define AZ_PROFILE_TIMER_END(_SectionVariableName)  { _SectionVariableName.Stop(); }
-
-/**
- * Macro to operate on custom values. All values are AZ::s64. You can provide up to 5 values.
- * format is AZ_PROFILE_VALUE_SET/ADD(const char* systemName, const char* valueName,
- * value1, optional value2, optional value3, optional value 4, optional value5, optional registerName (for direct register manipulation for EXPERTS ONLY)).
- * \param _SystemName is required and it's 'const char*' of the system name of which system this scope/register belongs to.
- * \param _RegisterName is required and it's 'const char*' with a name for the register - used as description.
- * \param 3 is required and it's AZ::s64, operates on m_value1.
- * \param 4 is optional and it's AZ::s64, operates on m_value2.
- * \param 5 is optional and it's AZ::s64, operates on m_value3.
- * \param 6 is optional and it's AZ::s64, operates on m_value4.
- * \param 7 is optional and it's AZ::s64, operates on m_value5.
- */
-#   define AZ_PROFILE_VALUE_SET(_SystemName, _RegisterName, ...)                                                                                                     \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                         \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                             \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                       \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::ValueCreate(_SystemName, _RegisterName, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                          \
-        }                                                                                                                                                            \
-        AZ_JOIN(azProfileRegister, __LINE__).m_register->ValueSet(__VA_ARGS__);                                                                                      \
-    }
-
-/// Same as AZ_PROFILE_VALUE_SET except is add the values passed in the macro (you can use -(value), to subtract values)
-#   define AZ_PROFILE_VALUE_ADD(_SystemName, _RegisterName, ...)                                                                                                     \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                         \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                             \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                       \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::ValueCreate(_SystemName, _RegisterName, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                          \
-        }                                                                                                                                                            \
-        AZ_JOIN(azProfileRegister, __LINE__).m_register->ValueAdd(__VA_ARGS__);                                                                                      \
-    }
-
-/**
- * Same as AZ_PROFILER_VALUE_SET but with option to access the register by name. (USE ONLY IN EXTREME CASES!!!)
- * \param _RegisterVaribaleName is optional unique name for a register C++ variable so you can manipulate the register.
- */
-#   define AZ_PROFILE_VALUE_SET_NAMED(_SystemName, _RegisterName, _RegisterVaribaleName, ...)                                                                        \
-    AZ::Debug::ProfilerRegister * _RegisterVaribaleName = nullptr;                                                                                                   \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                         \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                             \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                       \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::ValueCreate(_SystemName, _RegisterName, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                          \
-        }                                                                                                                                                            \
-        AZ_JOIN(azProfileRegister, __LINE__).m_register->ValueSet(__VA_ARGS__);                                                                                      \
-        _RegisterVaribaleName = AZ_JOIN(azProfileRegister, __LINE__).m_register;                                                                                     \
-    }
-
-/// Same as AZ_PROFILE_VALUE_SET_NAMED but add the values to the current. (USE ONLY IN EXTREME CASES!!!)
-#   define AZ_PROFILE_VALUE_ADD_NAMED(_SystemName, _RegisterName, _RegisterVaribaleName, ...)                                                                        \
-    AZ::Debug::ProfilerRegister * _RegisterVaribaleName = nullptr;                                                                                                   \
-    if (AZ::u64 profilerId = AZ::Debug::Profiler::GetId()) {                                                                                                         \
-        static AZ_THREAD_LOCAL AZ::Internal::RegisterData AZ_JOIN(azProfileRegister, __LINE__) = {0, 0};                                                             \
-        if (AZ_JOIN(azProfileRegister, __LINE__).m_profilerId != profilerId) {                                                                                       \
-            AZ_JOIN(azProfileRegister, __LINE__).m_register = AZ::Debug::ProfilerRegister::ValueCreate(_SystemName, _RegisterName, AZ_FUNCTION_SIGNATURE, __LINE__); \
-            AZ_JOIN(azProfileRegister, __LINE__).m_profilerId = profilerId;                                                                                          \
-        }                                                                                                                                                            \
-        AZ_JOIN(azProfileRegister, __LINE__).m_register->ValueAdd(__VA_ARGS__);                                                                                      \
-        _RegisterVaribaleName = AZ_JOIN(azProfileRegister, __LINE__).m_register;                                                                                     \
-    }
+#   define AZ_PROFILE_SCOPE(category, ...) ::AZ::ProfileScope AZ_JOIN(azProfileScope, __LINE__){ #category, __VA_ARGS__ }
+#   define AZ_PROFILE_FUNCTION(category) AZ_PROFILE_SCOPE(category, AZ_FUNCTION_SIGNATURE)
 
+// Prefer using the scoped macros which automatically end the event (AZ_PROFILE_SCOPE/AZ_PROFILE_FUNCTION)
+#   define AZ_PROFILE_BEGIN(category, ...) ::AZ::ProfileScope::BeginRegion(#category, __VA_ARGS__)
+#   define AZ_PROFILE_END() ::AZ::ProfileScope::EndRegion()
 #endif // AZ_PROFILER_MACRO_DISABLE
 
-#ifndef AZ_PROFILE_FUNCTION
-// No other profiler has defined the performance markers AZ_PROFILE_SCOPE (and friends), fallback to a Driller implementation
-#   define AZ_INTERNAL_PROF_VERIFY_CAT(category) static_assert(category < AZ::Debug::ProfileCategory::Count, "Invalid profile category")
-#   define AZ_INTERNAL_PROF_CAT_NAME(category) AZ::Debug::ProfileCategoryNames[static_cast<AZ::u32>(category)]
-
-#   define AZ_PROFILE_FUNCTION(category) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#   define AZ_PROFILE_FUNCTION_STALL(category) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#   define AZ_PROFILE_FUNCTION_IDLE(category) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-
-#   define AZ_PROFILE_SCOPE(category, name) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category)); (void)(name)
-#   define AZ_PROFILE_SCOPE_STALL(category, name) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category)); (void)(name)
-#   define AZ_PROFILE_SCOPE_IDLE(category, name) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category)); (void)(name)
-
-#   define AZ_PROFILE_SCOPE_DYNAMIC(category, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#   define AZ_PROFILE_SCOPE_STALL_DYNAMIC(category, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#   define AZ_PROFILE_SCOPE_IDLE_DYNAMIC(category, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_PROFILE_TIMER(AZ_INTERNAL_PROF_CAT_NAME(category))
-#endif
-
-#ifndef AZ_PROFILE_EVENT_BEGIN
-// No other profiler has defined the performance markers AZ_PROFILE_EVENT_START/END, fallback to a Driller implementation (currently empty)
-#   define AZ_PROFILE_EVENT_BEGIN(category, name) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); (void)(name)
-#   define AZ_PROFILE_EVENT_END(category) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category)
-#endif
-
 #ifndef AZ_PROFILE_INTERVAL_START
-// No other profiler has defined the performance markers AZ_PROFILE_INTERVAL_START/END, fallback to a Driller implementation (currently empty)
-#   define AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id) static_assert(sizeof(id) <= sizeof(AZ::u64), "Interval id must be a unique value no larger than 64-bits")
-#   define AZ_PROFILE_INTERVAL_START(category, id, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id)
-#   define AZ_PROFILE_INTERVAL_START_COLORED(category, id, color, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); (void)(color); AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id)
-#   define AZ_PROFILE_INTERVAL_END(category, id) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id)
-#   define AZ_PROFILE_INTERVAL_SCOPED(category, id, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); AZ_INTERNAL_PROF_VERIFY_INTERVAL_ID(id)
+#   define AZ_PROFILE_INTERVAL_START(...)
+#   define AZ_PROFILE_INTERVAL_START_COLORED(...)
+#   define AZ_PROFILE_INTERVAL_END(...)
+#   define AZ_PROFILE_INTERVAL_SCOPED(...)
 #endif
 
 #ifndef AZ_PROFILE_DATAPOINT
-// No other profiler has defined the performance markers AZ_PROFILE_DATAPOINT, fallback to a Driller implementation (currently empty)
-#define AZ_PROFILE_DATAPOINT(category, value, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); static_cast<double>(value)
-#define AZ_PROFILE_DATAPOINT_PERCENT(category, value, ...) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); static_cast<double>(value)
-#endif
-
-#ifndef AZ_PROFILE_MEMORY_ALLOC
-// No other profiler has defined the performance markers AZ_PROFILE_MEMORY_ALLOC (and friends), fall back to a Driller implementation (currently empty)
-#   define AZ_PROFILE_MEMORY_ALLOC(category, address, size, context) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); (void)(context)
-#   define AZ_PROFILE_MEMORY_ALLOC_EX(category, filename, lineNumber, address, size, context) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category); (void)(context)
-#   define AZ_PROFILE_MEMORY_FREE(category, address) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category)
-#   define AZ_PROFILE_MEMORY_FREE_EX(category, filename, lineNumber, address) \
-        AZ_INTERNAL_PROF_VERIFY_CAT(category)
+#   define AZ_PROFILE_DATAPOINT(...)
+#   define AZ_PROFILE_DATAPOINT_PERCENT(...)
 #endif
 
 namespace AZStd
@@ -318,6 +52,42 @@ namespace AZStd
 
 namespace AZ
 {
+    class ProfileScope
+    {
+    public:
+        static uint32_t GetSystemID(const char* system);
+
+        template<typename... T>
+        static void BeginRegion([[maybe_unused]] const char* system, [[maybe_unused]] const char* eventName, [[maybe_unused]] T const&... args)
+        {
+            // TODO: Verification that the supplied system name corresponds to a known budget
+#if defined(USE_PIX)
+            PIXBeginEvent(PIX_COLOR_INDEX(GetSystemID(system) & 0xff), eventName, args...);
+#endif
+            // TODO: injecting instrumentation for other profilers
+            // NOTE: external profiler registration won't occur inline in a header necessarily in this manner, but the exact mechanism
+            //       will be introduced in a future PR
+        }
+
+        static void EndRegion()
+        {
+#if defined(USE_PIX)
+            PIXEndEvent();
+#endif
+        }
+
+        template<typename... T>
+        ProfileScope(const char* system, char const* eventName, T const&... args)
+        {
+            BeginRegion(system, eventName, args...);
+        }
+
+        ~ProfileScope()
+        {
+            EndRegion();
+        }
+    };
+
     namespace Debug
     {
         class ProfilerSection;
@@ -615,5 +385,9 @@ namespace AZ
     }
 } // namespace AZ
 
-#endif // AZCORE_PROFILER_H
-#pragma once
+#ifdef USE_PIX
+// The pix3 header unfortunately brings in other Windows macros we need to undef
+#undef DeleteFile
+#undef LoadImage
+#undef GetCurrentTime
+#endif

Code/Framework/AzCore/AzCore/IO/ByteContainerStream.h

@@ -12,6 +12,7 @@
 #include <AzCore/Math/MathUtils.h>
 #include <AzCore/std/typetraits/is_const.h>
 #include <AzCore/std/typetraits/has_member_function.h>
+#include <AzCore/Casting/numeric_cast.h>
 
 namespace AZ
 {

Code/Framework/AzCore/AzCore/IO/FileIO.cpp

@@ -13,6 +13,7 @@
 #include <AzCore/std/string/wildcard.h>
 #include <AzCore/std/containers/array.h>
 #include <AzCore/PlatformIncl.h>
+#include <AzCore/Debug/Profiler.h>
 
 #ifndef SEEK_SET
 #  define SEEK_SET        0       /* Seek from beginning of file.  */
@@ -353,7 +354,7 @@ namespace AZ
                 m_filename = path;
             }
 
-            AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, &m_filename, 0xff0000ff, "FileIO: %s", m_filename.c_str());
+            AZ_PROFILE_INTERVAL_START_COLORED(AzCore, &m_filename, 0xff0000ff, "FileIO: %s", m_filename.c_str());
             return result;
         }
 
@@ -372,7 +373,7 @@ namespace AZ
                 FileIOBase::GetInstance()->Close(m_handle);
                 m_handle = InvalidHandle;
                 m_ownsHandle = false;
-                AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::AzCore, &m_filename);
+                AZ_PROFILE_INTERVAL_END(AzCore, &m_filename);
             }
         }
 
@@ -425,7 +426,7 @@ namespace AZ
 
         void FileIOStream::Seek(OffsetType bytes, SeekMode mode)
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "FileIO Seek: %s", m_filename.c_str());
+            AZ_PROFILE_SCOPE(AzCore, "FileIO Seek: %s", m_filename.c_str());
             AZ_Assert(FileIOBase::GetInstance(), "FileIO is not initialized.");
             AZ_Assert(IsOpen(), "Cannot seek on a FileIOStream that is not open.");
 
@@ -453,7 +454,7 @@ namespace AZ
 
         SizeType FileIOStream::Read(SizeType bytes, void* oBuffer)
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "FileIO Read: %s", m_filename.c_str());
+            AZ_PROFILE_SCOPE(AzCore, "FileIO Read: %s", m_filename.c_str());
             AZ_Assert(FileIOBase::GetInstance(), "FileIO is not initialized.");
             AZ_Assert(IsOpen(), "Cannot read from a FileIOStream that is not open.");
 

Code/Framework/AzCore/AzCore/IO/GenericStreams.cpp

@@ -11,6 +11,7 @@
 #include <AzCore/IO/SystemFile.h>
 #include <AzCore/IO/IOUtils.h>
 #include <AzCore/std/algorithm.h>
+#include <AzCore/Casting/numeric_cast.h>
 
 namespace AZ::IO
 {

Code/Framework/AzCore/AzCore/IO/Path/Path.inl

@@ -10,6 +10,7 @@
 
 #include <AzCore/std/containers/array.h>
 #include <AzCore/std/string/wildcard.h>
+#include <AzCore/Casting/numeric_cast.h>
 
 // extern instantiations of Path templates to prevent implicit instantiations
 namespace AZ::IO
@@ -221,7 +222,7 @@ namespace AZ::IO::Internal
             ? strncmp(left.data(), right.data(), maxCharsToCompare)
             : azstrnicmp(left.data(), right.data(), maxCharsToCompare);
         return charCompareResult == 0
-            ? aznumeric_cast<ptrdiff_t>(left.size()) - aznumeric_cast<ptrdiff_t>(right.size())
+            ? static_cast<int>(aznumeric_cast<ptrdiff_t>(left.size()) - aznumeric_cast<ptrdiff_t>(right.size()))
             : charCompareResult;
     }
 }

Code/Framework/AzCore/AzCore/IO/Streamer/BlockCache.cpp

@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/Streamer/BlockCache.h>
 #include <AzCore/IO/Streamer/FileRequest.h>
 #include <AzCore/IO/Streamer/StreamerContext.h>
@@ -38,7 +39,7 @@ namespace AZ
                 break;
             }
 
-            u32 cacheSize = m_cacheSizeMib * 1_mib;
+            u32 cacheSize = static_cast<AZ::u32>(m_cacheSizeMib * 1_mib);
             if (blockSize * 2 > cacheSize)
             {
                 AZ_Warning("Streamer", false, "Size (%u) for BlockCache isn't big enough to hold at least two cache blocks of size (%zu). "
@@ -188,7 +189,7 @@ namespace AZ
             s32 numAvailableSlots = CalculateAvailableRequestSlots();
             status.m_numAvailableSlots = AZStd::min(status.m_numAvailableSlots, numAvailableSlots);
             status.m_isIdle = status.m_isIdle &&
-                numAvailableSlots == m_numBlocks &&
+                static_cast<u32>(numAvailableSlots) == m_numBlocks &&
                 m_delayedSections.empty();
         }
 
@@ -245,7 +246,7 @@ namespace AZ
 
             auto continueReadFile = [this, request](FileRequest& fileSizeRequest)
             {
-                AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                AZ_PROFILE_FUNCTION(AzCore);
                 AZ_Assert(m_numMetaDataRetrievalInProgress > 0,
                     "More requests have completed meta data retrieval in the Block Cache than were requested.");
                 m_numMetaDataRetrievalInProgress--;
@@ -454,7 +455,7 @@ namespace AZ
                         section.m_readSize, sharedRead);
                     readRequest->SetCompletionCallback([this](FileRequest& request)
                         {
-                            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                            AZ_PROFILE_FUNCTION(AzCore);
                             CompleteRead(request);
                         });
                     section.m_cacheBlockIndex = cacheLocation;

Code/Framework/AzCore/AzCore/IO/Streamer/DedicatedCache.cpp

@@ -36,7 +36,7 @@ namespace AZ
                 break;
             }
 
-            u32 cacheSize = m_cacheSizeMib * 1_mib;
+            u32 cacheSize = static_cast<AZ::u32>(m_cacheSizeMib * 1_mib);
             if (blockSize > cacheSize)
             {
                 AZ_Warning("Streamer", false, "Size (%u) for DedicatedCache isn't big enough to hold at least one cache blocks of size (%zu). "

Code/Framework/AzCore/AzCore/IO/Streamer/FullFileDecompressor.cpp

@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/CompressionBus.h>
 #include <AzCore/IO/Streamer/FileRequest.h>
 #include <AzCore/IO/Streamer/FullFileDecompressor.h>
@@ -367,7 +368,7 @@ namespace AZ
                 {
                     auto callback = [this, nextRequest](const FileRequest& checkRequest)
                     {
-                        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                        AZ_PROFILE_FUNCTION(AzCore);
                         auto check = AZStd::get_if<FileRequest::FileExistsCheckData>(&checkRequest.GetCommand());
                         AZ_Assert(check,
                             "Callback in FullFileDecompressor::PrepareReadRequest expected FileExistsCheck but got another command.");
@@ -426,7 +427,7 @@ namespace AZ
                 {
                     auto callback = [this, nextRequest](const FileRequest& checkRequest)
                     {
-                        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                        AZ_PROFILE_FUNCTION(AzCore);
                         auto check = AZStd::get_if<FileRequest::FileExistsCheckData>(&checkRequest.GetCommand());
                         AZ_Assert(check,
                             "Callback in FullFileDecompressor::PrepareDedicatedCache expected FileExistsCheck but got another command.");
@@ -508,7 +509,7 @@ namespace AZ
                     archiveReadRequest->SetCompletionCallback(
                         [this, readSlot = i](FileRequest& request)
                         {
-                            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                            AZ_PROFILE_FUNCTION(AzCore);
                             FinishArchiveRead(&request, readSlot);
                         });
                     m_next->QueueRequest(archiveReadRequest);
@@ -596,7 +597,7 @@ namespace AZ
 
                     waitRequest->SetCompletionCallback([this, jobSlot](FileRequest& request)
                         {
-                            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                            AZ_PROFILE_FUNCTION(AzCore);
                             FinishDecompression(&request, jobSlot);
                         });
 

Code/Framework/AzCore/AzCore/IO/Streamer/ReadSplitter.cpp

@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/Streamer/FileRequest.h>
 #include <AzCore/IO/Streamer/ReadSplitter.h>
 #include <AzCore/IO/Streamer/StreamerContext.h>
@@ -218,7 +219,7 @@ namespace AZ
                 subRequest->CreateRead(pending.m_request, pending.m_output, bufferSize, data->m_path, pending.m_offset, readSize, data->m_sharedRead);
                 subRequest->SetCompletionCallback([this](FileRequest&)
                     {
-                        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                        AZ_PROFILE_FUNCTION(AzCore);
                         QueuePendingRequest();
                     });
                 m_next->QueueRequest(subRequest);
@@ -302,7 +303,7 @@ namespace AZ
                         offset, readSize, data->m_sharedRead);
                     subRequest->SetCompletionCallback([this, bufferSlot]([[maybe_unused]] FileRequest& request)
                         {
-                            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+                            AZ_PROFILE_FUNCTION(AzCore);
 
                             BufferCopyInformation& copyInfo = m_bufferCopyInformation[bufferSlot];
                             memcpy(copyInfo.m_target, GetBufferSlot(bufferSlot) + copyInfo.m_bufferOffset, copyInfo.m_size);

Code/Framework/AzCore/AzCore/IO/Streamer/Scheduler.cpp

@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/Streamer/Scheduler.h>
 #include <AzCore/std/containers/deque.h>
 #include <AzCore/std/sort.h>
@@ -138,14 +139,14 @@ namespace AZ::IO
         while (m_isRunning)
         {
             {
-                AZ_PROFILE_SCOPE_IDLE(AZ::Debug::ProfileCategory::AzCore, "Scheduler suspended.");
+                AZ_PROFILE_SCOPE(AzCore, "Scheduler suspended.");
                 m_context.SuspendSchedulingThread();
             }
 
             // Only do processing if the thread hasn't been suspended.
             while (!m_isSuspended)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "Scheduler main loop.");
+                AZ_PROFILE_SCOPE(AzCore, "Scheduler main loop.");
 
                 // Always schedule requests first as the main Streamer thread could have been asleep for a long time due to slow reading
                 // but also don't schedule after every change in the queue as scheduling is not cheap.
@@ -154,7 +155,7 @@ namespace AZ::IO
                 {
                     do
                     {
-                        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "Scheduler queue requests.");
+                        AZ_PROFILE_SCOPE(AzCore, "Scheduler queue requests.");
                         // If there are pending requests and available slots, queue the next requests.
                         while(m_context.GetNumPreparedRequests() > 0)
                         {
@@ -208,7 +209,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_QueueNextRequest()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         FileRequest* next = m_context.PopPreparedRequest();
         next->SetStatus(IStreamerTypes::RequestStatus::Processing);
@@ -279,7 +280,7 @@ namespace AZ::IO
                     m_processingSize += info.m_uncompressedSize;
 #endif
                 }
-                AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, next, ProfilerColor,
+                AZ_PROFILE_INTERVAL_START_COLORED(AzCore, next, ProfilerColor,
                     "Streamer queued %zu: %s", next->GetCommand().index(), parentReadRequest->m_path.GetRelativePath());
                 m_threadData.m_streamStack->QueueRequest(next);
             }
@@ -293,7 +294,7 @@ namespace AZ::IO
             }
             else if constexpr (AZStd::is_same_v<Command, FileRequest::FlushData> || AZStd::is_same_v<Command, FileRequest::FlushAllData>)
             {
-                AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, next, ProfilerColor,
+                AZ_PROFILE_INTERVAL_START_COLORED(AzCore, next, ProfilerColor,
                     "Streamer queued %zu", next->GetCommand().index());
                 // Flushing becomes a lot less complicated if there are no jobs and/or asynchronous I/O running. This does mean overall
                 // longer processing time as bubbles are introduced into the pipeline, but flushing is an infrequent event that only
@@ -303,7 +304,7 @@ namespace AZ::IO
             }
             else
             {
-                AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, next, ProfilerColor,
+                AZ_PROFILE_INTERVAL_START_COLORED(AzCore, next, ProfilerColor,
                     "Streamer queued %zu", next->GetCommand().index());
                 m_threadData.m_streamStack->QueueRequest(next);
             }
@@ -312,13 +313,13 @@ namespace AZ::IO
 
     bool Scheduler::Thread_ExecuteRequests()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         return m_threadData.m_streamStack->ExecuteRequests();
     }
 
     bool Scheduler::Thread_PrepareRequests(AZStd::vector<FileRequestPtr>& outstandingRequests)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         {
             AZStd::scoped_lock lock(m_pendingRequestsLock);
@@ -372,7 +373,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_ProcessTillIdle()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         while (true)
         {
@@ -390,7 +391,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_ProcessCancelRequest(FileRequest* request, FileRequest::CancelData& data)
     {
-        AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, request, ProfilerColor, "Streamer queued cancel");
+        AZ_PROFILE_INTERVAL_START_COLORED(AzCore, request, ProfilerColor, "Streamer queued cancel");
         auto& pending = m_context.GetPreparedRequests();
         auto pendingIt = pending.begin();
         while (pendingIt != pending.end())
@@ -412,7 +413,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_ProcessRescheduleRequest(FileRequest* request, FileRequest::RescheduleData& data)
     {
-        AZ_PROFILE_INTERVAL_START_COLORED(AZ::Debug::ProfileCategory::AzCore, request, ProfilerColor, "Streamer queued reschedule");
+        AZ_PROFILE_INTERVAL_START_COLORED(AzCore, request, ProfilerColor, "Streamer queued reschedule");
         auto& pendingRequests = m_context.GetPreparedRequests();
         for (FileRequest* pending : pendingRequests)
         {
@@ -543,7 +544,7 @@ namespace AZ::IO
 
     void Scheduler::Thread_ScheduleRequests()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         AZStd::chrono::system_clock::time_point now = AZStd::chrono::system_clock::now();
         auto& pendingQueue = m_context.GetPreparedRequests();
@@ -554,7 +555,7 @@ namespace AZ::IO
 
         if (m_context.GetNumPreparedRequests() > 1)
         {
-            AZ_PROFILE_SCOPE_DYNAMIC(AZ::Debug::ProfileCategory::AzCore,
+            AZ_PROFILE_SCOPE(AzCore,
                 "Scheduler::Thread_ScheduleRequests - Sorting %i requests", m_context.GetNumPreparedRequests());
             auto sorter = [this](const FileRequest* lhs, const FileRequest* rhs) -> bool
             {

Code/Framework/AzCore/AzCore/IO/Streamer/Statistics.cpp

@@ -48,7 +48,7 @@ namespace AZ
             [[maybe_unused]] AZStd::string_view name,
             [[maybe_unused]] double value)
         {
-            AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::AzCore, value,
+            AZ_PROFILE_DATAPOINT(AzCore, value,
                 "Streamer/%.*s/%.*s (Raw)",
                 aznumeric_cast<int>(owner.size()), owner.data(),
                 aznumeric_cast<int>(name.size()), name.data());

Code/Framework/AzCore/AzCore/IO/Streamer/StorageDrive.cpp

@@ -59,7 +59,7 @@ namespace AZ
 
         void StorageDrive::PrepareRequest(FileRequest* request)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             AZ_Assert(request, "PrepareRequest was provided a null request.");
 
             if (AZStd::holds_alternative<FileRequest::ReadRequestData>(request->GetCommand()))
@@ -254,7 +254,7 @@ namespace AZ
 
         void StorageDrive::ReadFile(FileRequest* request)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             auto data = AZStd::get_if<FileRequest::ReadData>(&request->GetCommand());
             AZ_Assert(data, "FileRequest queued on StorageDrive to be read didn't contain read data.");
@@ -341,7 +341,7 @@ namespace AZ
 
         void StorageDrive::FileExistsRequest(FileRequest* request)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             TIMED_AVERAGE_WINDOW_SCOPE(m_getFileExistsTimeAverage);
 
             auto& fileExists = AZStd::get<FileRequest::FileExistsCheckData>(request->GetCommand());
@@ -359,7 +359,7 @@ namespace AZ
 
         void StorageDrive::FileMetaDataRetrievalRequest(FileRequest* request)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             TIMED_AVERAGE_WINDOW_SCOPE(m_getFileMetaDataTimeAverage);
 
             auto& command = AZStd::get<FileRequest::FileMetaDataRetrievalData>(request->GetCommand());

Code/Framework/AzCore/AzCore/IO/Streamer/Streamer.cpp

@@ -7,6 +7,7 @@
  */
 
 #include <AzCore/Casting/numeric_cast.h>
+#include <AzCore/Debug/Profiler.h>
 #include <AzCore/IO/CompressionBus.h>
 #include <AzCore/IO/Streamer/Streamer.h>
 #include <AzCore/IO/Streamer/StreamerConfiguration.h>
@@ -262,15 +263,15 @@ namespace AZ::IO
             switch (stat.GetType())
             {
             case Statistic::Type::FloatingPoint:
-                AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::AzCore, stat.GetFloatValue(), "Streamer/%.*s/%.*s",
+                AZ_PROFILE_DATAPOINT(AzCore, stat.GetFloatValue(), "Streamer/%.*s/%.*s",
                     aznumeric_cast<int>(stat.GetOwner().length()), stat.GetOwner().data(), aznumeric_cast<int>(stat.GetName().length()), stat.GetName().data());
                 break;
             case Statistic::Type::Integer:
-                AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::AzCore, stat.GetIntegerValue(), "Streamer/%.*s/%.*s",
+                AZ_PROFILE_DATAPOINT(AzCore, stat.GetIntegerValue(), "Streamer/%.*s/%.*s",
                     aznumeric_cast<int>(stat.GetOwner().length()), stat.GetOwner().data(), aznumeric_cast<int>(stat.GetName().length()), stat.GetName().data());
                 break;
             case Statistic::Type::Percentage:
-                AZ_PROFILE_DATAPOINT_PERCENT(AZ::Debug::ProfileCategory::AzCore, stat.GetPercentage(), "Streamer/%.*s/%.*s (percent)",
+                AZ_PROFILE_DATAPOINT_PERCENT(AzCore, stat.GetPercentage(), "Streamer/%.*s/%.*s (percent)",
                     aznumeric_cast<int>(stat.GetOwner().length()), stat.GetOwner().data(), aznumeric_cast<int>(stat.GetName().length()), stat.GetName().data());
                 break;
             default:

Code/Framework/AzCore/AzCore/IO/Streamer/StreamerContext.cpp

@@ -153,7 +153,7 @@ namespace AZ
 
         bool StreamerContext::FinalizeCompletedRequests()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
 #if AZ_STREAMER_ADD_EXTRA_PROFILING_INFO
             auto now = AZStd::chrono::system_clock::now();
@@ -218,10 +218,10 @@ namespace AZ
                     bool isInternal = top->m_usage == FileRequest::Usage::Internal;
 
                     {
-                        AZ_PROFILE_SCOPE_STALL(AZ::Debug::ProfileCategory::AzCore,
+                        AZ_PROFILE_SCOPE(AzCore,
                             isInternal ? "Completion callback internal" : "Completion callback external");
                         top->m_onCompletion(*top);
-                        AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::AzCore, top);
+                        AZ_PROFILE_INTERVAL_END(AzCore, top);
                     }
                     
                     if (parent)

Code/Framework/AzCore/AzCore/IO/SystemFile.cpp

@@ -9,7 +9,6 @@
 #include <AzCore/IO/SystemFile.h>
 #include <AzCore/IO/FileIO.h>
 #include <AzCore/IO/FileIOEventBus.h>
-#include <AzCore/Debug/Profiler.h>
 
 #include <AzCore/PlatformIncl.h>
 #include <AzCore/std/functional.h>
@@ -97,9 +96,6 @@ SystemFile& SystemFile::operator=(SystemFile&& other)
 
 bool SystemFile::Open(const char* fileName, int mode, int platformFlags)
 {
-    AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory::AzCore, this, "SystemFile::Open - %s", fileName);
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Open - %s", fileName);
-
     if (fileName)       // If we reopen the file we are allowed to have NULL file name
     {
         if (strlen(fileName) > m_fileName.max_size())
@@ -136,9 +132,6 @@ bool SystemFile::ReOpen(int mode, int platformFlags)
 
 void SystemFile::Close()
 {
-    AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory::AzCore, this, "SystemFile::Close - %s", m_fileName.c_str());
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Close - %s", m_fileName.c_str());
-
     if (FileIOBus::HasHandlers())
     {
         bool isHandled = false;
@@ -154,8 +147,6 @@ void SystemFile::Close()
 
 void SystemFile::Seek(SeekSizeType offset, SeekMode mode)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Seek - %s:%i", m_fileName.c_str(), offset);
-
     if (FileIOBus::HasHandlers())
     {
         bool isHandled = false;
@@ -181,16 +172,11 @@ bool SystemFile::Eof()
 
 AZ::u64 SystemFile::ModificationTime()
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::ModTime - %s", m_fileName.c_str());
-
     return Platform::ModificationTime(m_handle, this);
 }
 
 SystemFile::SizeType SystemFile::Read(SizeType byteSize, void* buffer)
 {
-    AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory::AzCore, this, "SystemFile::Read - %s:%i", m_fileName.c_str(), byteSize);
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Read - %s:%i", m_fileName.c_str(), byteSize);
-
     if (FileIOBus::HasHandlers())
     {
         SizeType numRead = 0;
@@ -207,9 +193,6 @@ SystemFile::SizeType SystemFile::Read(SizeType byteSize, void* buffer)
 
 SystemFile::SizeType SystemFile::Write(const void* buffer, SizeType byteSize)
 {
-    AZ_PROFILE_INTERVAL_SCOPED(AZ::Debug::ProfileCategory::AzCore, this, "SystemFile::Write - %s:%i", m_fileName.c_str(), byteSize);
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Write - %s:%i", m_fileName.c_str(), byteSize);
-
     if (FileIOBus::HasHandlers())
     {
         SizeType numWritten = 0;
@@ -226,15 +209,11 @@ SystemFile::SizeType SystemFile::Write(const void* buffer, SizeType byteSize)
 
 void SystemFile::Flush()
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Flush - %s", m_fileName.c_str());
-
     Platform::Flush(m_handle, this);
 }
 
 SystemFile::SizeType SystemFile::Length() const
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Length - %s", m_fileName.c_str());
-
     return Platform::Length(m_handle, this);
 }
 
@@ -253,36 +232,26 @@ SystemFile::SizeType SystemFile::DiskOffset() const
 
 bool SystemFile::Exists(const char* fileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Exists(util) - %s", fileName);
-
     return Platform::Exists(fileName);
 }
 
 void SystemFile::FindFiles(const char* filter, FindFileCB cb)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::FindFiles(util) - %s", filter);
-
     Platform::FindFiles(filter, cb);
 }
 
 AZ::u64 SystemFile::ModificationTime(const char* fileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::ModTime(util) - %s", fileName);
-
     return Platform::ModificationTime(fileName);
 }
 
 SystemFile::SizeType SystemFile::Length(const char* fileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Length(util) - %s", fileName);
-
     return Platform::Length(fileName);
 }
 
 SystemFile::SizeType SystemFile::Read(const char* fileName, void* buffer, SizeType byteSize, SizeType byteOffset)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Read(util) - %s:[%i,%i]", fileName, byteOffset, byteSize);
-
     SizeType numBytesRead = 0;
     SystemFile f;
     if (f.Open(fileName, SF_OPEN_READ_ONLY))
@@ -305,8 +274,6 @@ SystemFile::SizeType SystemFile::Read(const char* fileName, void* buffer, SizeTy
 
 bool SystemFile::Delete(const char* fileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Delete(util) - %s", fileName);
-
     if (!Exists(fileName))
     {
         return false;
@@ -317,8 +284,6 @@ bool SystemFile::Delete(const char* fileName)
 
 bool SystemFile::Rename(const char* sourceFileName, const char* targetFileName, bool overwrite)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::Rename(util) - %s", sourceFileName);
-
     if (!Exists(sourceFileName))
     {
         return false;
@@ -329,29 +294,21 @@ bool SystemFile::Rename(const char* sourceFileName, const char* targetFileName,
 
 bool SystemFile::IsWritable(const char* sourceFileName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::IsWritable(util) - %s", sourceFileName);
-
     return Platform::IsWritable(sourceFileName);
 }
 
 bool SystemFile::SetWritable(const char* sourceFileName, bool writable)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::SetWritable(util) - %s", sourceFileName);
-
     return Platform::SetWritable(sourceFileName, writable);
 }
 
 bool SystemFile::CreateDir(const char* dirName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::CreateDir(util) - %s", dirName);
-
     return Platform::CreateDir(dirName);
 }
 
 bool SystemFile::DeleteDir(const char* dirName)
 {
-    AZ_PROFILE_SCOPE_STALL_DYNAMIC(AZ::Debug::ProfileCategory::AzCore, "SystemFile::DeleteDir(util) - %s", dirName);
-
     return Platform::DeleteDir(dirName);
 }
 

Code/Framework/AzCore/AzCore/Jobs/Algorithms.h

@@ -13,11 +13,6 @@
 
 #include <AzCore/std/parallel/spin_mutex.h>
 
-#ifdef AZ_COMPILER_MSVC
-# pragma warning(push)
-# pragma warning(disable: 4355) // 'this' : used in base member initializer list
-#endif
-
 // A reasonable define for a stack allocator size for the high level jobs.
 #define AZ_JOBS_DEFAULT_STACK_ALLOCATOR_SIZE AZStd::GetMax<unsigned>(2048,512 * AZStd::thread::hardware_concurrency())
 
@@ -769,9 +764,5 @@ namespace AZ
     }
 }
 
-#ifdef AZ_COMPILER_MSVC
-# pragma warning(pop)
-#endif
-
 #endif
 #pragma once

Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerBase.cpp

@@ -23,10 +23,10 @@ void JobManagerBase::Process(Job* job)
     Job* dependent = job->GetDependent();
     bool isDelete = job->IsAutoDelete();
 
-    AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::JobManagerDetailed, job);
+    AZ_PROFILE_INTERVAL_END(JobManagerDetailed, job);
     if (!job->IsCancelled())
     {
-        AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "AZ::JobManagerBase::Process Job");
+        AZ_PROFILE_SCOPE(AzCore, "AZ::JobManagerBase::Process Job");
         job->Process();
     }
 

Code/Framework/AzCore/AzCore/Jobs/Internal/JobManagerWorkStealing.cpp

@@ -122,7 +122,7 @@ void JobManagerWorkStealing::AddPendingJob(Job* job)
     }
 #endif
 
-    AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::JobManagerDetailed, job, "AzCore Job Queued Awaiting Execute");
+    AZ_PROFILE_INTERVAL_START(JobManagerDetailed, job, "AzCore Job Queued Awaiting Execute");
 
     if (job->IsCompletion())
     {
@@ -371,7 +371,7 @@ void JobManagerWorkStealing::ProcessJobsInternal(ThreadInfo* info, Job* suspende
                 {
                     //no available work, so go to sleep (or we have already been signaled by another thread and will acquire the semaphore but not actually sleep)
                     info->m_waitEvent.acquire();
-                    AZ_PROFILE_INTERVAL_END(AZ::Debug::ProfileCategory::JobManagerDetailed, info);
+                    AZ_PROFILE_INTERVAL_END(JobManagerDetailed, info);
 
                     if (m_quitRequested)
                     {
@@ -457,7 +457,7 @@ void JobManagerWorkStealing::ProcessJobsInternal(ThreadInfo* info, Job* suspende
             else
             {
                 //attempt to steal a job from another thread's queue
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "JobManagerWorkStealing::ProcessJobsInternal:WorkStealing");
+                AZ_PROFILE_SCOPE(AzCore, "JobManagerWorkStealing::ProcessJobsInternal:WorkStealing");
 
                 unsigned int numStealAttempts = 0;
                 const unsigned int maxStealAttempts = (unsigned int)m_workerThreads.size() * 3; //try every thread a few times before giving up
@@ -674,7 +674,7 @@ inline void JobManagerWorkStealing::ActivateWorker()
                 m_numAvailableWorkers.fetch_sub(1, AZStd::memory_order_acq_rel);
                 // resume the thread execution
 
-                AZ_PROFILE_INTERVAL_START(AZ::Debug::ProfileCategory::JobManagerDetailed, info, "AzCore WakeJobThread %d", info->m_workerId);
+                AZ_PROFILE_INTERVAL_START(JobManagerDetailed, info, "AzCore WakeJobThread %d", info->m_workerId);
                 info->m_waitEvent.release();
                 return;
             }

Code/Framework/AzCore/AzCore/Jobs/JobCompletion.h

@@ -33,7 +33,7 @@ namespace AZ
          */
         void StartAndWaitForCompletion()
         {
-            AZ_PROFILE_FUNCTION_STALL(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             // start the job
             Start();

Code/Framework/AzCore/AzCore/Jobs/LegacyJobExecutor.h

@@ -72,7 +72,7 @@ namespace AZ
 
             while (m_running)
             {
-                AZ_PROFILE_FUNCTION_STALL(AZ::Debug::ProfileCategory::AzCore);
+                AZ_PROFILE_FUNCTION(AzCore);
                 m_completionCondition.wait(uniqueLock, [this] { return !this->m_running; });
             }
         }

Code/Framework/AzCore/AzCore/Math/Internal/SimdMathVec4_scalar.inl

@@ -10,12 +10,9 @@
 
 #include <AzCore/Math/Internal/SimdMathCommon_scalar.inl>
 
-#ifdef _MSC_VER
 // Unity builds on windows using the scalar backend are tripping some really strange warning behavior..
 // Disable the warning so we can test the scalar implementation with unity on windows
-#   pragma warning (push)
-#   pragma warning (disable: 4723) // Potential divide by zero
-#endif
+AZ_PUSH_DISABLE_WARNING(4723, "-Wunknown-warning-option") // Potential divide by zero
 
 namespace AZ
 {
@@ -1049,6 +1046,4 @@ namespace AZ
     }
 }
 
-#ifdef _MSC_VER
-#   pragma warning (pop)
-#endif
+AZ_POP_DISABLE_WARNING

Code/Framework/AzCore/AzCore/Math/MatrixUtils.cpp

@@ -57,7 +57,7 @@ namespace AZ
 
     float GetPerspectiveMatrixFOV(const Matrix4x4& m)
     {
-        return 2.0 * AZStd::atan(1.0f / m.GetElement(1, 1));
+        return 2.0f * AZStd::atan(1.0f / m.GetElement(1, 1));
     }
 
     Matrix4x4* MakeFrustumMatrixRH(Matrix4x4& out, float left, float right, float bottom, float top, float nearDist, float farDist, bool reverseDepth)

Code/Framework/AzCore/AzCore/Math/Quaternion.h

@@ -246,10 +246,6 @@ namespace AZ
         //! Takes the absolute value of each component of the quaternion.
         Quaternion GetAbs() const;
 
-#ifdef AZ_COMPILER_MSVC
-#   pragma warning(push)
-#   pragma warning(disable:4201) // anonymous union
-#endif
         union
         {
             Simd::Vec4::FloatType m_value;
@@ -263,9 +259,6 @@ namespace AZ
                 float m_w;
             };
         };
-#ifdef AZ_COMPILER_MSVC
-#   pragma warning(pop)
-#endif
     };
 
     //! Non-member functionality belonging to the AZ namespace

Code/Framework/AzCore/AzCore/Math/Vector2.h

@@ -281,10 +281,6 @@ namespace AZ
 
     private:
 
-#ifdef AZ_COMPILER_MSVC
-#   pragma warning(push)
-#   pragma warning(disable:4201) // anonymous union
-#endif
         union
         {
             Simd::Vec2::FloatType m_value;
@@ -296,9 +292,6 @@ namespace AZ
                 float m_y;
             };
         };
-#ifdef AZ_COMPILER_MSVC
-#   pragma warning(pop)
-#endif
     };
 
     //! Allows pre-multiplying by a float.

Code/Framework/AzCore/AzCore/Math/Vector3.h

@@ -312,10 +312,6 @@ namespace AZ
 
     private:
 
-#ifdef AZ_COMPILER_MSVC
-#   pragma warning(push)
-#   pragma warning(disable:4201) // anonymous union
-#endif
         union
         {
             Simd::Vec3::FloatType m_value;
@@ -328,9 +324,6 @@ namespace AZ
                 float m_z;
             };
         };
-#ifdef AZ_COMPILER_MSVC
-#   pragma warning(pop)
-#endif
     };
 
     //! Non member functionality belonging to the AZ namespace.

Code/Framework/AzCore/AzCore/Math/Vector4.h

@@ -283,11 +283,6 @@ namespace AZ
         Simd::Vec4::FloatType GetSimdValue() const;
 
     protected:
-
-#ifdef AZ_COMPILER_MSVC
-#   pragma warning(push)
-#   pragma warning(disable:4201) // anonymous union
-#endif
         union
         {
             Simd::Vec4::FloatType m_value;
@@ -301,9 +296,6 @@ namespace AZ
                 float m_w;
             };
         };
-#ifdef AZ_COMPILER_MSVC
-#   pragma warning(pop)
-#endif
     };
 }
 

Code/Framework/AzCore/AzCore/Memory/AllocationRecords.cpp

@@ -11,6 +11,7 @@
 #include <AzCore/Memory/AllocatorManager.h>
 #include <AzCore/Driller/DrillerBus.h>
 
+#include <AzCore/std/time.h>
 #include <AzCore/std/parallel/mutex.h>
 
 #include <AzCore/Debug/StackTracer.h>

Code/Framework/AzCore/AzCore/Memory/SimpleSchemaAllocator.h

@@ -12,9 +12,7 @@
 #include <AzCore/std/typetraits/aligned_storage.h>
 #include <AzCore/std/typetraits/alignment_of.h>
 #include <AzCore/Memory/AllocatorBase.h>
-#include <AzCore/Debug/Profiler.h>
-
-#include <AzCore/Memory/AllocatorBase.h>
+#include <AzCore/Debug/MemoryProfiler.h>
 
 namespace AZ
 {
@@ -82,7 +80,7 @@ namespace AZ
 
             if (ProfileAllocations)
             {
-                AZ_PROFILE_MEMORY_ALLOC_EX(AZ::Debug::ProfileCategory::MemoryReserved, fileName, lineNum, ptr, byteSize, name ? name : GetName());
+                AZ_PROFILE_MEMORY_ALLOC_EX(MemoryReserved, fileName, lineNum, ptr, byteSize, name ? name : GetName());
                 AZ_MEMORY_PROFILE(ProfileAllocation(ptr, byteSize, alignment, name, fileName, lineNum, suppressStackRecord));
             }
 
@@ -102,7 +100,7 @@ namespace AZ
 
             if (ProfileAllocations)
             {
-                AZ_PROFILE_MEMORY_FREE(AZ::Debug::ProfileCategory::MemoryReserved, ptr);
+                AZ_PROFILE_MEMORY_FREE(MemoryReserved, ptr);
                 AZ_MEMORY_PROFILE(ProfileDeallocation(ptr, byteSize, alignment, nullptr));
             }
 
@@ -128,7 +126,7 @@ namespace AZ
         {
             if (ProfileAllocations)
             {
-                AZ_PROFILE_MEMORY_FREE(AZ::Debug::ProfileCategory::MemoryReserved, ptr);
+                AZ_PROFILE_MEMORY_FREE(MemoryReserved, ptr);
             }
 
             newSize = MemorySizeAdjustedUp(newSize);
@@ -142,7 +140,7 @@ namespace AZ
 
             if (ProfileAllocations)
             {
-                AZ_PROFILE_MEMORY_ALLOC(AZ::Debug::ProfileCategory::MemoryReserved, newPtr, newSize, GetName());
+                AZ_PROFILE_MEMORY_ALLOC(MemoryReserved, newPtr, newSize, GetName());
                 AZ_MEMORY_PROFILE(ProfileReallocationEnd(ptr, newPtr, newSize, newAlignment));
             }
 

Code/Framework/AzCore/AzCore/Memory/SystemAllocator.cpp

@@ -17,15 +17,23 @@
 
 #include <AzCore/Debug/Profiler.h>
 
-#define AZCORE_SYS_ALLOCATOR_HPPA  // If you disable this make sure you start building the heapschema.cpp
-//#define AZCORE_SYS_ALLOCATOR_MALLOC
+#define AZCORE_SYSTEM_ALLOCATOR_HPHA 1
+#define AZCORE_SYSTEM_ALLOCATOR_MALLOC 2
+#define AZCORE_SYSTEM_ALLOCATOR_HEAP 3
 
-#ifdef AZCORE_SYS_ALLOCATOR_HPPA
-#   include <AzCore/Memory/HphaSchema.h>
-#elif defined(AZCORE_SYS_ALLOCATOR_MALLOC)
-#include <AzCore/Memory/MallocSchema.h>
+#if !defined(AZCORE_SYSTEM_ALLOCATOR)
+    // define the default
+    #define AZCORE_SYSTEM_ALLOCATOR AZCORE_SYSTEM_ALLOCATOR_HPHA
+#endif
+
+#if AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HPHA
+    #include <AzCore/Memory/HphaSchema.h>
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_MALLOC
+    #include <AzCore/Memory/MallocSchema.h>
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HEAP
+    #include <AzCore/Memory/HeapSchema.h>
 #else
-#   include <AzCore/Memory/HeapSchema.h>
+    #error "Invalid allocator selected for SystemAllocator"
 #endif
 
 
@@ -34,12 +42,12 @@ using namespace AZ;
 //////////////////////////////////////////////////////////////////////////
 // Globals - we use global storage for the first memory schema, since we can't use dynamic memory!
 static bool g_isSystemSchemaUsed = false;
-#ifdef AZCORE_SYS_ALLOCATOR_HPPA
-static AZStd::aligned_storage<sizeof(HphaSchema), AZStd::alignment_of<HphaSchema>::value>::type g_systemSchema;
-#elif defined(AZCORE_SYS_ALLOCATOR_MALLOC)
-static AZStd::aligned_storage<sizeof(MallocSchema), AZStd::alignment_of<MallocSchema>::value>::type g_systemSchema;
-#else
-static AZStd::aligned_storage<sizeof(HeapSchema), AZStd::alignment_of<HeapSchema>::value>::type g_systemSchema;
+#if AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HPHA
+    static AZStd::aligned_storage<sizeof(HphaSchema), AZStd::alignment_of<HphaSchema>::value>::type g_systemSchema;
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_MALLOC
+    static AZStd::aligned_storage<sizeof(MallocSchema), AZStd::alignment_of<MallocSchema>::value>::type g_systemSchema;
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HEAP
+    static AZStd::aligned_storage<sizeof(HeapSchema), AZStd::alignment_of<HeapSchema>::value>::type g_systemSchema;
 #endif
 
 //////////////////////////////////////////////////////////////////////////
@@ -97,9 +105,9 @@ SystemAllocator::Create(const Descriptor& desc)
     else
     {
         m_isCustom = false;
-#ifdef AZCORE_SYS_ALLOCATOR_HPPA
-        HphaSchema::Descriptor      heapDesc;
-        heapDesc.m_pageSize     = desc.m_heap.m_pageSize;
+#if AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HPHA
+        HphaSchema::Descriptor heapDesc;
+        heapDesc.m_pageSize = desc.m_heap.m_pageSize;
         heapDesc.m_poolPageSize = desc.m_heap.m_poolPageSize;
         AZ_Assert(desc.m_heap.m_numFixedMemoryBlocks <= 1, "We support max1 memory block at the moment!");
         if (desc.m_heap.m_numFixedMemoryBlocks > 0)
@@ -111,11 +119,10 @@ SystemAllocator::Create(const Descriptor& desc)
         heapDesc.m_isPoolAllocations = desc.m_heap.m_isPoolAllocations;
         // Fix SystemAllocator from growing in small chunks
         heapDesc.m_systemChunkSize = desc.m_heap.m_systemChunkSize;
-
-#elif defined(AZCORE_SYS_ALLOCATOR_MALLOC)
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_MALLOC
         MallocSchema::Descriptor heapDesc;
-#else
-        HeapSchema::Descriptor      heapDesc;
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HEAP
+        HeapSchema::Descriptor heapDesc;
         memcpy(heapDesc.m_memoryBlocks, desc.m_heap.m_memoryBlocks, sizeof(heapDesc.m_memoryBlocks));
         memcpy(heapDesc.m_memoryBlocksByteSize, desc.m_heap.m_memoryBlocksByteSize, sizeof(heapDesc.m_memoryBlocksByteSize));
         heapDesc.m_numMemoryBlocks = desc.m_heap.m_numMemoryBlocks;
@@ -124,11 +131,11 @@ SystemAllocator::Create(const Descriptor& desc)
         {
             AZ_Assert(!g_isSystemSchemaUsed, "AZ::SystemAllocator MUST be created first! It's the source of all allocations!");
 
-#ifdef AZCORE_SYS_ALLOCATOR_HPPA
+#if AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HPHA
             m_allocator = new(&g_systemSchema)HphaSchema(heapDesc);
-#elif defined(AZCORE_SYS_ALLOCATOR_MALLOC)
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_MALLOC
             m_allocator = new(&g_systemSchema)MallocSchema(heapDesc);
-#else
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HEAP
             m_allocator = new(&g_systemSchema)HeapSchema(heapDesc);
 #endif
             g_isSystemSchemaUsed = true;
@@ -139,14 +146,13 @@ SystemAllocator::Create(const Descriptor& desc)
             // this class should be inheriting from SystemAllocator
             AZ_Assert(AllocatorInstance<SystemAllocator>::IsReady(), "System allocator must be created before any other allocator! They allocate from it.");
 
-#ifdef AZCORE_SYS_ALLOCATOR_HPPA
+#if AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HPHA
             m_allocator = azcreate(HphaSchema, (heapDesc), SystemAllocator);
-#elif defined(AZCORE_SYS_ALLOCATOR_MALLOC)
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_MALLOC
             m_allocator = azcreate(MallocSchema, (heapDesc), SystemAllocator);
-#else
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HEAP
             m_allocator = azcreate(HeapSchema, (heapDesc), SystemAllocator);
 #endif
-
             if (m_allocator == NULL)
             {
                 isReady = false;
@@ -178,11 +184,11 @@ SystemAllocator::Destroy()
     {
         if ((void*)m_allocator == (void*)&g_systemSchema)
         {
-#ifdef AZCORE_SYS_ALLOCATOR_HPPA
+#if AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HPHA
             static_cast<HphaSchema*>(m_allocator)->~HphaSchema();
-#elif defined(AZCORE_SYS_ALLOCATOR_MALLOC)
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_MALLOC
             static_cast<MallocSchema*>(m_allocator)->~MallocSchema();
-#else
+#elif AZCORE_SYSTEM_ALLOCATOR == AZCORE_SYSTEM_ALLOCATOR_HEAP
             static_cast<HeapSchema*>(m_allocator)->~HeapSchema();
 #endif
             g_isSystemSchemaUsed = false;
@@ -254,7 +260,7 @@ SystemAllocator::Allocate(size_type byteSize, size_type alignment, int flags, co
 
     AZ_Assert(address != 0, "SystemAllocator: Failed to allocate %d bytes aligned on %d (flags: 0x%08x) %s : %s (%d)!", byteSize, alignment, flags, name ? name : "(no name)", fileName ? fileName : "(no file name)", lineNum);
 
-    AZ_PROFILE_MEMORY_ALLOC_EX(AZ::Debug::ProfileCategory::MemoryReserved, fileName, lineNum, address, byteSize, name);
+    AZ_PROFILE_MEMORY_ALLOC_EX(MemoryReserved, fileName, lineNum, address, byteSize, name);
     AZ_MEMORY_PROFILE(ProfileAllocation(address, byteSize, alignment, name, fileName, lineNum, suppressStackRecord + 1));
 
     return address;
@@ -268,7 +274,7 @@ void
 SystemAllocator::DeAllocate(pointer_type ptr, size_type byteSize, size_type alignment)
 {
     byteSize = MemorySizeAdjustedUp(byteSize);
-    AZ_PROFILE_MEMORY_FREE(AZ::Debug::ProfileCategory::MemoryReserved, ptr);
+    AZ_PROFILE_MEMORY_FREE(MemoryReserved, ptr);
     AZ_MEMORY_PROFILE(ProfileDeallocation(ptr, byteSize, alignment, nullptr));
     m_allocator->DeAllocate(ptr, byteSize, alignment);
 }
@@ -283,9 +289,9 @@ SystemAllocator::ReAllocate(pointer_type ptr, size_type newSize, size_type newAl
     newSize = MemorySizeAdjustedUp(newSize);
 
     AZ_MEMORY_PROFILE(ProfileReallocationBegin(ptr, newSize));
-    AZ_PROFILE_MEMORY_FREE(AZ::Debug::ProfileCategory::MemoryReserved, ptr);
+    AZ_PROFILE_MEMORY_FREE(MemoryReserved, ptr);
     pointer_type newAddress = m_allocator->ReAllocate(ptr, newSize, newAlignment);
-    AZ_PROFILE_MEMORY_ALLOC(AZ::Debug::ProfileCategory::MemoryReserved, newAddress, newSize, "SystemAllocator realloc");
+    AZ_PROFILE_MEMORY_ALLOC(MemoryReserved, newAddress, newSize, "SystemAllocator realloc");
     AZ_MEMORY_PROFILE(ProfileReallocationEnd(ptr, newAddress, newSize, newAlignment));
 
     return newAddress;

Code/Framework/AzCore/AzCore/Memory/dlmalloc.inl

@@ -1294,14 +1294,6 @@ int mspace_mallopt(int, int);
 
 /*------------------------------ internal #includes ---------------------- */
 
-#ifdef WIN32
-#pragma warning(push)
-#pragma warning( disable : 4146 ) /* no "unsigned" warnings */
-#   ifdef AZ_PLATFORM_WINDOWS
-#       pragma warning( disable : 4267 )
-#   endif
-#endif /* WIN32 */
-
 #include <stdio.h>       /* for printing in malloc_stats */
 
 #ifndef LACKS_ERRNO_H
@@ -2170,7 +2162,7 @@ typedef unsigned int flag_t;           /* The type of various bit flag sets */
 #define align_as_chunk(A)   (mchunkptr)((A) + align_offset(chunk2mem(A)))
 
 /* Bounds on request (not chunk) sizes. */
-#define MAX_REQUEST         ((-MIN_CHUNK_SIZE) << 2)
+#define MAX_REQUEST         ((~MIN_CHUNK_SIZE + 1) << 2)
 #define MIN_REQUEST         (MIN_CHUNK_SIZE - CHUNK_OVERHEAD - SIZE_T_ONE)
 
 /* pad request bytes into a usable size */
@@ -2881,10 +2873,10 @@ static size_t traverse_and_check(mstate m);
 #define treemap_is_marked(M, i)  ((M)->treemap  &   idx2bit(i))
 
 /* isolate the least set bit of a bitmap */
-#define least_bit(x)         ((x) & - (x))
+#define least_bit(x)         ((x) & (~(x)+1))
 
 /* mask with all bits to left of least bit of x on */
-#define left_bits(x)         ((x << 1) | -(x << 1))
+#define left_bits(x)         ((x << 1) | (~(x << 1)+1))
 
 /* mask with all bits to left of or equal to least bit of x on */
 #define same_or_left_bits(x) ((x) | -(x))
@@ -4528,7 +4520,7 @@ static int sys_trim(mstate m, size_t pad)
 static void* tmalloc_large(mstate m, size_t nb)
 {
     tchunkptr v = 0;
-    size_t rsize = -nb; /* Unsigned negation */
+    size_t rsize = ~nb+1; /* Unsigned negation */
     tchunkptr t;
     bindex_t idx;
     compute_tree_index(nb, idx);
@@ -4807,7 +4799,7 @@ static void* internal_memalign(mstate m, size_t alignment, size_t bytes)
                 char* br = (char*)mem2chunk((size_t)(((size_t)(mem +
                                                                alignment -
                                                                SIZE_T_ONE)) &
-                                                     - alignment));
+                                                     (~alignment+1)));
                 char* pos = ((size_t)(br - (char*)(p)) >= MIN_CHUNK_SIZE) ?
                     br : br + alignment;
                 mchunkptr newp = (mchunkptr)pos;
@@ -5489,7 +5481,7 @@ postaction:
         size_t msize;
         ensure_initialization();
         msize = pad_request(sizeof(struct malloc_state));
-        if (capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size))
+        if (capacity < (~(msize + TOP_FOOT_SIZE + mparams.page_size)+1))
         {
             size_t rs = ((capacity == 0) ? mparams.granularity :
                          (capacity + TOP_FOOT_SIZE + msize));
@@ -5512,7 +5504,7 @@ postaction:
         ensure_initialization();
         msize = pad_request(sizeof(struct malloc_state));
         if (capacity > msize + TOP_FOOT_SIZE &&
-            capacity < (size_t) -(msize + TOP_FOOT_SIZE + mparams.page_size))
+            capacity < (~(msize + TOP_FOOT_SIZE + mparams.page_size)+1))
         {
             m = init_user_mstate((char*)base, capacity);
             m->seg.sflags = EXTERN_BIT;
@@ -6367,6 +6359,3 @@ postaction:
 
     */
 
-#ifdef WIN32
-#pragma warning(pop)
-#endif /* WIN32 */

Code/Framework/AzCore/AzCore/Module/Module.h

@@ -9,7 +9,6 @@
 #define AZCORE_MODULE_INCLUDE_H 1
 
 #include <AzCore/Component/Component.h>
-#include <AzCore/Debug/ProfileModuleInit.h>
 #include <AzCore/Memory/SystemAllocator.h>
 #include <AzCore/Module/Environment.h>
 #include <AzCore/Interface/Interface.h>
@@ -78,9 +77,6 @@ namespace AZ
 
     protected:
         AZStd::list<AZ::ComponentDescriptor*> m_descriptors;
-
-    private:
-        AZ::Debug::ProfileModuleInitializer m_moduleProfilerInit;
     };
 } // namespace AZ
 
@@ -98,19 +94,26 @@ namespace AZ
 ///
 /// \param MODULE_NAME      Name of module.
 /// \param MODULE_CLASSNAME Name of AZ::Module class (include namespace).
+///
+/// Execute any deferred console commands after linking any new deferred functors
+/// This allows deferred console commands defined within the module to now execute
+/// at this point now that the module has been loaded
 #if defined(AZ_MONOLITHIC_BUILD)
 #   define AZ_DECLARE_MODULE_CLASS(MODULE_NAME, MODULE_CLASSNAME) \
     extern "C" AZ::Module * CreateModuleClass_##MODULE_NAME() { return aznew MODULE_CLASSNAME; }
 #else
 #   define AZ_DECLARE_MODULE_CLASS(MODULE_NAME, MODULE_CLASSNAME)                                \
     AZ_DECLARE_MODULE_INITIALIZATION                                                             \
-    extern "C" AZ_DLL_EXPORT AZ::Module * CreateModuleClass()                                    \
+    extern "C" AZ_DLL_EXPORT AZ::Module* CreateModuleClass()                                     \
     {                                                                                            \
-        AZ::ConsoleFunctorBase*& deferredHead = AZ::ConsoleFunctorBase::GetDeferredHead();       \
-        AZ::Interface<AZ::IConsole>::Get()->LinkDeferredFunctors(deferredHead);                  \
+        if (auto console = AZ::Interface<AZ::IConsole>::Get(); console != nullptr)               \
+        {                                                                                        \
+             console->LinkDeferredFunctors(AZ::ConsoleFunctorBase::GetDeferredHead());           \
+             console->ExecuteDeferredConsoleCommands();                                          \
+        }                                                                                        \
         return aznew MODULE_CLASSNAME;                                                           \
     }                                                                                            \
-    extern "C" AZ_DLL_EXPORT void DestroyModuleClass(AZ::Module * module) { delete module; }
+    extern "C" AZ_DLL_EXPORT void DestroyModuleClass(AZ::Module* module) { delete module; }
 #endif
 
 #endif // AZCORE_MODULE_INCLUDE_H

Code/Framework/AzCore/AzCore/Name/Internal/NameData.cpp

@@ -36,10 +36,13 @@ namespace AZ
 
         void NameData::release()
         {
+            // this could be released after we decrement the counter, therefore we will
+            // base the release on the hash which is stable
+            Hash hash = m_hash;
             AZ_Assert(m_useCount > 0, "m_useCount is already 0!");
             if (m_useCount.fetch_sub(1) == 1)
             {
-                AZ::NameDictionary::Instance().TryReleaseName(this);
+                AZ::NameDictionary::Instance().TryReleaseName(hash);
             }
         }
     }

Code/Framework/AzCore/AzCore/Name/Name.h

@@ -10,6 +10,11 @@
 
 #include <AzCore/Name/Internal/NameData.h>
 
+namespace UnitTest
+{
+    class NameTest;
+}
+
 namespace AZ
 {
     class NameDictionary;
@@ -29,6 +34,7 @@ namespace AZ
     class Name
     {
         friend NameDictionary;
+        friend UnitTest::NameTest;
     public:
         using Hash = Internal::NameData::Hash;
 

Code/Framework/AzCore/AzCore/Name/NameDictionary.cpp

@@ -166,7 +166,7 @@ namespace AZ
         }
     }
 
-    void NameDictionary::TryReleaseName(Internal::NameData* nameData)
+    void NameDictionary::TryReleaseName(Name::Hash hash)
     {
         // Note that we don't remove NameData from the dictionary if it has been involved in a collision.
         // This avoids specific edge cases where a Name object could get an incorrect hash value. Consider
@@ -179,15 +179,24 @@ namespace AZ
         //      the dictionary *again*, this time with hash value 1000. Name objects pointing to the original
         //      entry and Name objects pointing to the new entry will fail comparison operations.
 
-        // Early exit to avoid locking the mutex unnecessarily.
-        if (nameData->m_hashCollision)
-        {
-            return;
-        }
 
         AZStd::unique_lock<AZStd::shared_mutex> lock(m_sharedMutex);
 
-        // Check m_hashCollision again inside the m_sharedMutex because a new collision could have happened
+        auto dictIt = m_dictionary.find(hash);
+        if (dictIt == m_dictionary.end())
+        {
+            // This check is to safeguard around the following scenario
+            // T1, gets into TryReleaseName
+            // T2 gets into MakeName, acquires the lock, returns a new Name that increments the counter
+            // T2 deletes the Name decrements the counter, gets into TryReleaseName
+            // T1 gets the lock, goes to the compare_exchange if and has a counter of 0, deletes
+            // Then T2 continues, gets the lock and crashes because nameData was deleted
+            return;
+        }
+
+        Internal::NameData* nameData = dictIt->second;
+
+        // Check m_hashCollision inside the m_sharedMutex because a new collision could have happened
         // on another thread before taking the lock.
         if (nameData->m_hashCollision)
         {

Code/Framework/AzCore/AzCore/Name/NameDictionary.h

@@ -83,7 +83,7 @@ namespace AZ
 
         // Attempts to release the name from the dictionary, but checks to make sure
         // a reference wasn't taken by another thread.
-        void TryReleaseName(Internal::NameData* data);
+        void TryReleaseName(Name::Hash hash);
         
         //////////////////////////////////////////////////////////////////////////
 

Code/Framework/AzCore/AzCore/PlatformDef.h

@@ -87,9 +87,6 @@
 #define AZ_POP_DISABLE_DLL_EXPORT_MEMBER_WARNING AZ_POP_DISABLE_WARNING
 
 #   define AZ_FORCE_INLINE  __forceinline
-#if !defined(_DEBUG)
-#   pragma warning(disable:4714) //warning C4714 marked as __forceinline not inlined. Sadly this happens when LTCG during linking. We tried to NOT use force inline but VC 2012 is bad at inlining.
-#endif
 
 /// Aligns a declaration.
 #   define AZ_ALIGN(_decl, _alignment) \

Code/Framework/AzCore/AzCore/RTTI/BehaviorContext.h

@@ -24,11 +24,6 @@
 #include <AzCore/Outcome/Outcome.h>
 #include <AzCore/Script/ScriptContextAttributes.h>
 
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning(push)
-#   pragma warning(disable: 4127) // conditional expression is constant
-#endif
-
 namespace AZStd
 {
     template <typename T>
@@ -1855,7 +1850,7 @@ namespace AZ
  *      {
  *          // do any conversion of caching of the "data" here and forward this to behavior (often the reason for this is that you can't pass everything to behavior
  *          // plus behavior can't really handle all constructs pointer to pointer, rvalues, etc. as they don't make sense for most script environments
- *          int result = 0; // set the default value for your result if the behavior if there is no implmentation
+ *          int result = 0; // set the default value for your result if the behavior if there is no implementation
  *          // The AZ_EBUS_BEHAVIOR_BINDER defines FN_EventName for each index. You can also cache it yourself (but it's slower), static int cacheIndex = GetFunctionIndex("OnEvent1"); and use that .
  *          CallResult(result, FN_OnEvent1, data);  // forward to the binding (there can be none, this is why we need to always have properly set result, when there is one)
  *          return result; // return the result like you will in any normal EBus even with result
@@ -4507,7 +4502,7 @@ namespace AZ
             params.resize(sizeof...(Args) + eBehaviorBusForwarderEventIndices::ParameterFirst);
             SetParameters<R>(&params[eBehaviorBusForwarderEventIndices::Result], nullptr);
             SetParameters<void*>(&params[eBehaviorBusForwarderEventIndices::UserData], nullptr);
-            if (sizeof...(Args) > 0)
+            if constexpr (sizeof...(Args) > 0)
             {
                 SetParameters<Args...>(&params[eBehaviorBusForwarderEventIndices::ParameterFirst], nullptr);
             }
@@ -4872,10 +4867,6 @@ namespace AZ
     } // namespace Internal
 } // namespace AZ
 
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning(pop)
-#endif
-
 // pull AzStd on demand reflection
 #include <AzCore/RTTI/AzStdOnDemandPrettyName.inl>
 #include <AzCore/RTTI/AzStdOnDemandReflection.inl>

Code/Framework/AzCore/AzCore/Script/ScriptSystemComponent.cpp

@@ -287,14 +287,6 @@ void    ScriptSystemComponent::OnSystemTick()
             contextContainer.m_context->GetDebugContext()->ProcessDebugCommands();
         }
 
-#ifdef AZ_PROFILE_TELEMETRY
-        if (contextContainer.m_context->GetId() == ScriptContextIds::DefaultScriptContextId)
-        {
-            size_t memoryUsageBytes = contextContainer.m_context->GetMemoryUsage();
-            AZ_PROFILE_DATAPOINT(AZ::Debug::ProfileCategory::Script, memoryUsageBytes / 1024.0, "Script Memory (KB)");
-        }
-#endif // AZ_PROFILE_TELEMETRY
-
         contextContainer.m_context->GarbageCollectStep(contextContainer.m_garbageCollectorSteps);
     }
 }

Code/Framework/AzCore/AzCore/Serialization/DataPatch.cpp

@@ -143,7 +143,7 @@ namespace AZ
     //=========================================================================
     void DataNodeTree::Build(const void* rootClassPtr, const Uuid& rootClassId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         m_root.Reset();
         m_currentNode = nullptr;
@@ -1400,7 +1400,7 @@ namespace AZ
 
         AddressTypeElement AddressTypeSerializer::LoadAddressElementFromPath(const AZStd::string& pathElement) const
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             // AddressTypeElement default constructor defaults to an invalid addressElement
             AddressTypeElement addressElement;
@@ -1485,13 +1485,13 @@ namespace AZ
         /// Load the class data from a stream.
         bool AddressTypeSerializer::Load(void* classPtr, IO::GenericStream& stream, unsigned int version, bool isDataBigEndian /*= false*/)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
             (void)isDataBigEndian;
             constexpr unsigned int version1PathAddress = 1;
 
             if (version < version1PathAddress)
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "AddressTypeSerializer::Load::LegacyUpgrade");
+                AZ_PROFILE_SCOPE(AzCore, "AddressTypeSerializer::Load::LegacyUpgrade");
                 // Grab the AddressType object to be filled
                 AddressType* address = reinterpret_cast<AddressType*>(classPtr);
                 address->clear();
@@ -1516,7 +1516,7 @@ namespace AZ
             }
             else
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "AddressTypeSerializer::Load::CurrentFlow");
+                AZ_PROFILE_SCOPE(AzCore, "AddressTypeSerializer::Load::CurrentFlow");
                 // Grab the AddressType object to be filled
                 AddressType* address = reinterpret_cast<AddressType*>(classPtr);
                 address->clear();
@@ -1749,7 +1749,7 @@ namespace AZ
         const FlagsMap& targetFlagsMap,
         SerializeContext* context)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!source || !target)
         {
@@ -1804,7 +1804,7 @@ namespace AZ
             targetTree.Build(target, targetClassId);
 
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "DataPatch::Create:RecursiveCallToCompareElements");
+                AZ_PROFILE_SCOPE(AzCore, "DataPatch::Create:RecursiveCallToCompareElements");
 
                 sourceTree.CompareElements(
                     &sourceTree.m_root,
@@ -1829,7 +1829,7 @@ namespace AZ
         const FlagsMap& sourceFlagsMap,
         const FlagsMap& targetFlagsMap) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!source)
         {
@@ -1870,7 +1870,7 @@ namespace AZ
 
         {
             // Loop over the original data patch and make a copy of the key value pair
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "DataPatch::Apply:UpgradeDataPatch");
+            AZ_PROFILE_SCOPE(AzCore, "DataPatch::Apply:UpgradeDataPatch");
             // Copy of the patch element is purposefully being created here(notice no ampersand) so that the UpgradeDataPatch
             // function can modify the key and insert it into the fixed patch map
             for (PatchMap::value_type patch : m_patch)
@@ -1883,7 +1883,7 @@ namespace AZ
         // Build a mapping of child patches for quick look-up: [parent patch address] -> [list of patches for child elements (parentAddress + one more address element)]
             ChildPatchMap childPatchMap;
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "DataPatch::Apply:GenerateChildPatchMap");
+            AZ_PROFILE_SCOPE(AzCore, "DataPatch::Apply:GenerateChildPatchMap");
             for (auto& patch : fixedPatch)
             {
                 AddressType parentAddress = patch.first;
@@ -1921,7 +1921,7 @@ namespace AZ
             }
         }
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "DataPatch::Apply:RecursiveCallToApplyToElements");
+            AZ_PROFILE_SCOPE(AzCore, "DataPatch::Apply:RecursiveCallToApplyToElements");
             int rootContainerElementCounter = 0;
 
             result = DataNodeTree::ApplyToElements(
@@ -2015,7 +2015,7 @@ namespace AZ
     */
     bool LegacyDataPatchConverter(AZ::SerializeContext& context, AZ::SerializeContext::DataElementNode& classElement)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZ::Outcome<void, AZStd::string> conversionResult = LegacyDataPatchConverter_Impl(context, classElement);
 
         if (!conversionResult.IsSuccess())
@@ -2043,7 +2043,7 @@ namespace AZ
     */
     AZ::Outcome<void, AZStd::string> LegacyDataPatchConverter_Impl(AZ::SerializeContext& context, AZ::SerializeContext::DataElementNode& classElement)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         // Pull the targetClassId value out of the class element before it gets cleared when converting the DataPatch TypeId
         AZ::TypeId targetClassTypeId;
         if (!classElement.GetChildData(AZ_CRC("m_targetClassId", 0xcabab9dc), targetClassTypeId))

Code/Framework/AzCore/AzCore/Serialization/EditContext.h

@@ -656,26 +656,25 @@ namespace AZ
         using ElementType = typename AZStd::Utils::if_c<AZStd::is_enum<typename ElementTypeInfo::Type>::value, typename ElementTypeInfo::Type, typename ElementTypeInfo::ElementType>::type;
         AZ_Assert(m_classData->m_typeId == AzTypeInfo<typename ElementTypeInfo::ClassType>::Uuid(), "Data element (%s) belongs to a different class!", AzTypeInfo<typename ElementTypeInfo::ValueType>::Name());
 
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning(push)
-#   pragma warning(disable: 4127) // conditional expression is constant
-#endif
         const SerializeContext::ClassData* classData = m_context->m_serializeContext.FindClassData(AzTypeInfo<typename ElementTypeInfo::ValueType>::Uuid());
         if (classData && classData->m_editData)
         {
             return DataElement<T>(uiId, memberVariable, classData->m_editData->m_name, classData->m_editData->m_description);
         }
-        else if (AZStd::is_enum<ElementType>::value && AzTypeInfo<ElementType>::Name() != nullptr)
+        else
         {
-            auto enumIter = m_context->m_enumData.find(AzTypeInfo<ElementType>::Uuid());
-            if (enumIter != m_context->m_enumData.end())
+            if constexpr (AZStd::is_enum<ElementType>::value)
             {
-                return DataElement<T>(uiId, memberVariable, enumIter->second.m_name, enumIter->second.m_description);
+                if (AzTypeInfo<ElementType>::Name() != nullptr)
+                {
+                    auto enumIter = m_context->m_enumData.find(AzTypeInfo<ElementType>::Uuid());
+                    if (enumIter != m_context->m_enumData.end())
+                    {
+                        return DataElement<T>(uiId, memberVariable, enumIter->second.m_name, enumIter->second.m_description);
+                    }
+                }
             }
         }
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning(pop)
-#endif
         
         const char* typeName = AzTypeInfo<typename ElementTypeInfo::ValueType>::Name();
         return DataElement<T>(uiId, memberVariable, typeName, typeName);

Code/Framework/AzCore/AzCore/Serialization/ObjectStream.cpp

@@ -786,7 +786,7 @@ namespace AZ
                 // Serializable leaf element.
                 else if (classData->m_serializer)
                 {
-                    AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "ObjectStreamImpl::LoadClass Load");
+                    AZ_PROFILE_SCOPE(AzCore, "ObjectStreamImpl::LoadClass Load");
 
                     // Wrap the stream
                     IO::GenericStream* currentStream = &m_inStream;
@@ -1929,7 +1929,7 @@ namespace AZ
         //=========================================================================
         bool ObjectStreamImpl::Start()
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             ++m_pending;
 

Code/Framework/AzCore/AzCore/Serialization/SerializationUtils.cpp

@@ -24,7 +24,7 @@ namespace AZ
     {
         bool LoadObjectFromStreamInPlace(IO::GenericStream& stream, AZ::SerializeContext* context, const SerializeContext::ClassData* objectClassData, void* targetPointer, const FilterDescriptor& filterDesc)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             AZ_Assert(objectClassData, "Class data is required.");
 
@@ -72,7 +72,7 @@ namespace AZ
 
         bool LoadObjectFromStreamInPlace(IO::GenericStream& stream, AZ::SerializeContext* context, const Uuid& targetClassId, void* targetPointer, const FilterDescriptor& filterDesc)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             if (!context)
             {
@@ -111,7 +111,7 @@ namespace AZ
 
         void* LoadObjectFromStream(IO::GenericStream& stream, AZ::SerializeContext* context, const Uuid* targetClassId, const FilterDescriptor& filterDesc)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             if (!context)
             {
@@ -169,7 +169,7 @@ namespace AZ
 
         void* LoadObjectFromFile(const AZStd::string& filePath, const Uuid& targetClassId, SerializeContext* context, const FilterDescriptor& filterDesc, int /*platformFlags*/)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             AZ::IO::FileIOStream fileStream;           
             if (!fileStream.Open(filePath.c_str(), IO::OpenMode::ModeRead | IO::OpenMode::ModeBinary))
@@ -183,7 +183,7 @@ namespace AZ
 
         bool SaveObjectToStream(IO::GenericStream& stream, DataStream::StreamType streamType, const void* classPtr, const Uuid& classId, SerializeContext* context, const SerializeContext::ClassData* classData)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             if (!context)
             {
@@ -243,7 +243,7 @@ namespace AZ
 
         bool SaveObjectToFile(const AZStd::string& filePath, DataStream::StreamType fileType, const void* classPtr, const Uuid& classId, SerializeContext* context, int platformFlags)
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             // \note This is ok for tools, but we should use the streamer to write objects directly (no memory store)
             AZStd::vector<AZ::u8> dstData;

Code/Framework/AzCore/AzCore/Slice/SliceComponent.cpp

@@ -198,7 +198,7 @@ namespace AZ
         const EntityIdToEntityIdMap* remapFromIdToId/*=nullptr*/,
         const DataFlagsTransformFunction& dataFlagsTransformFn/*=nullptr*/)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         for (const auto& entityIdFlagsMapPair : from.m_entityToDataFlags)
         {
@@ -240,7 +240,7 @@ namespace AZ
     //=========================================================================
     DataPatch::FlagsMap SliceComponent::DataFlagsPerEntity::GetDataFlagsForPatching(const EntityIdToEntityIdMap* remapFromIdToId /*=nullptr*/) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Collect together data flags from all entities
         DataPatch::FlagsMap dataFlagsForAllEntities;
@@ -423,7 +423,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::DataFlagsPerEntity::Cleanup(const EntityList& validEntities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         EntityIdSet validEntityIds;
         for (const Entity* entity : validEntities)
@@ -677,7 +677,7 @@ namespace AZ
     //=========================================================================
     SliceComponent::SliceInstance* SliceComponent::SliceReference::PrepareCreateInstance(const SliceInstanceId& sliceInstanceId, bool allowUninstantiated)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // create an empty instance (just copy of the existing data)
         SliceInstance* instance = CreateEmptyInstance(sliceInstanceId);
@@ -737,7 +737,7 @@ namespace AZ
         AZ::SerializeContext* serializeContext,
         const AZ::IdUtils::Remapper<AZ::EntityId>::IdMapper& customMapper)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!remapContainer)
         {
@@ -808,7 +808,7 @@ namespace AZ
     SliceComponent::SliceInstance* SliceComponent::SliceReference::CreateInstance(const AZ::IdUtils::Remapper<AZ::EntityId>::IdMapper& customMapper, 
         SliceInstanceId sliceInstanceId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Validate that we are able to create an instance at this time
         // If we are instantiated then this includes verifying that we have a valid component and asset
@@ -842,7 +842,7 @@ namespace AZ
         const EntityIdToEntityIdMap assetToLiveIdMap,
         SliceInstanceId sliceInstanceId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Validate that we are able to create an instance at this time
         // This includes verifying that we are instantiated, and have a valid component and asset
@@ -883,7 +883,7 @@ namespace AZ
     SliceComponent::SliceInstance* SliceComponent::SliceReference::CloneInstance(SliceComponent::SliceInstance* instance, 
                                                                                  SliceComponent::EntityIdToEntityIdMap& sourceToCloneEntityIdMap)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // check if source instance belongs to this slice reference
         auto findIt = AZStd::find_if(m_instances.begin(), m_instances.end(), [instance](const SliceInstance& element) -> bool { return &element == instance; });
@@ -1053,7 +1053,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::SliceReference::Instantiate(const AZ::ObjectStream::FilterDescriptor& filterDesc)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (m_isInstantiated)
         {
@@ -1145,7 +1145,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::SliceReference::InstantiateInstance(SliceInstance& instance, const AZ::ObjectStream::FilterDescriptor& filterDesc)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Could have set this during SliceInstance() constructor, but we wait until instantiation since it involves allocation.
         instance.m_dataFlags.SetIsValidEntityFunction([&instance](EntityId entityId) { return instance.IsValidEntity(entityId); });
@@ -1167,7 +1167,7 @@ namespace AZ
         // An empty map indicates its a fresh instance (i.e. has never be instantiated and then serialized).
         if (entityIdMap.empty())
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "SliceComponent::SliceReference::InstantiateInstance:FreshInstanceClone");
+            AZ_PROFILE_SCOPE(AzCore, "SliceComponent::SliceReference::InstantiateInstance:FreshInstanceClone");
 
             // Generate new Ids and populate the map.
             AZ_Assert(!dataPatch.IsValid(), "Data patch is valid for slice instance, but entity Id map is not!");
@@ -1175,7 +1175,7 @@ namespace AZ
         }
         else
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "SliceComponent::SliceReference::InstantiateInstance:CloneAndApplyDataPatches");
+            AZ_PROFILE_SCOPE(AzCore, "SliceComponent::SliceReference::InstantiateInstance:CloneAndApplyDataPatches");
 
             // Clone entities while applying any data patches.
             AZ_Assert(dataPatch.IsValid(), "Data patch is not valid for existing slice instance!");
@@ -1261,7 +1261,7 @@ namespace AZ
         // Broadcast OnSliceEntitiesLoaded for freshly instantiated entities.
         if (!instance.m_instantiated->m_entities.empty())
         {
-            AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "SliceComponent::SliceReference::InstantiateInstance:OnSliceEntitiesLoaded");
+            AZ_PROFILE_SCOPE(AzCore, "SliceComponent::SliceReference::InstantiateInstance:OnSliceEntitiesLoaded");
             SliceAssetSerializationNotificationBus::Broadcast(&SliceAssetSerializationNotificationBus::Events::OnSliceEntitiesLoaded, instance.m_instantiated->m_entities);
         }
     }
@@ -1363,7 +1363,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::SliceReference::ComputeDataPatch()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // Get source entities from the base asset (instantiate if needed)
         InstantiatedContainer source(m_asset.Get()->GetComponent(), false);
@@ -1499,7 +1499,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::GetEntities(EntityList& entities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         bool result = true;
 
@@ -1532,7 +1532,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::GetEntityIds(EntityIdSet& entities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         bool result = true;
 
@@ -1582,7 +1582,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::GetMetadataEntityIds(EntityIdSet& metadataEntities)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         bool result = true;
 
@@ -1654,7 +1654,7 @@ namespace AZ
     //=========================================================================
     SliceComponent::InstantiateResult SliceComponent::Instantiate()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZStd::unique_lock<AZStd::recursive_mutex> lock(m_instantiateMutex);
 
         if (m_slicesAreInstantiated)
@@ -1856,7 +1856,7 @@ namespace AZ
     SliceComponent::SliceInstanceAddress SliceComponent::AddSliceUsingExistingEntities(const Data::Asset<SliceAsset>& sliceAsset, const AZ::SliceComponent::EntityIdToEntityIdMap& liveToAssetMap,
         SliceInstanceId sliceInstanceId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!sliceAsset.Get()->GetComponent())
         {
@@ -2337,7 +2337,7 @@ namespace AZ
     //=========================================================================
     bool SliceComponent::RemoveSliceInstance(SliceComponent::SliceInstanceAddress sliceAddress)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         if (!sliceAddress.IsValid())
         {
             AZ_Error("Slices", false, "Slice address is invalid.");
@@ -2474,7 +2474,7 @@ namespace AZ
 
     bool SliceComponent::RemoveMetaDataEntity(EntityId metaDataEntityId)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         GetEntityInfoMap(); // Ensure map is built
 
@@ -2567,7 +2567,7 @@ namespace AZ
 
     void SliceComponent::RemoveAllEntities(bool deleteEntities, bool removeEmptyInstances)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         // If we are deleting the entities, we need to do that one by one
         if (deleteEntities)
@@ -2930,7 +2930,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::OnAssetReloaded(Data::Asset<Data::AssetData> /*asset*/)
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!m_myAsset)
         {
@@ -3073,7 +3073,7 @@ namespace AZ
         /// Called right after we finish writing data to the instance pointed at by classPtr.
         void OnWriteEnd(void* classPtr) override
         {
-            AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+            AZ_PROFILE_FUNCTION(AzCore);
 
             SliceComponent* sliceComponent = reinterpret_cast<SliceComponent*>(classPtr);
             EBUS_EVENT(SliceAssetSerializationNotificationBus, OnWriteDataToSliceAssetEnd, *sliceComponent);
@@ -3082,7 +3082,7 @@ namespace AZ
             // We can't broadcast this event for instanced entities yet, since they don't exist until instantiation.
             if (!sliceComponent->GetNewEntities().empty())
             {
-                AZ_PROFILE_SCOPE(AZ::Debug::ProfileCategory::AzCore, "SliceComponentSerializationEvents::OnWriteEnd:OnSliceEntitiesLoaded");
+                AZ_PROFILE_SCOPE(AzCore, "SliceComponentSerializationEvents::OnWriteEnd:OnSliceEntitiesLoaded");
                 EBUS_EVENT(SliceAssetSerializationNotificationBus, OnSliceEntitiesLoaded, sliceComponent->GetNewEntities());
             }
         }
@@ -3093,7 +3093,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::PrepareSave()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (m_slicesAreInstantiated)
         {
@@ -3262,7 +3262,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::BuildEntityInfoMap()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         m_entityInfoMap.clear();
         m_metaDataEntityInfoMap.clear();
@@ -3425,7 +3425,7 @@ namespace AZ
     //=========================================================================
     void SliceComponent::BuildDataFlagsForInstances()
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
         AZ_Assert(IsInstantiated(), "Slice must be instantiated before the ancestry of its data flags can be calculated.");
 
         // Use lock since slice instantiation can occur from multiple threads
@@ -3551,7 +3551,7 @@ namespace AZ
     {
         // if this function is a performance bottleneck, it could be optimized with caching
         // be wary not to create the cache in-game if the information is only needed by tools
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         if (!IsInstantiated())
         {
@@ -3730,7 +3730,7 @@ namespace AZ
     //=========================================================================
     SliceComponent* SliceComponent::Clone(AZ::SerializeContext& serializeContext, SliceInstanceToSliceInstanceMap* sourceToCloneSliceInstanceMap) const
     {
-        AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzCore);
+        AZ_PROFILE_FUNCTION(AzCore);
 
         SliceComponent* clonedComponent = serializeContext.CloneObject(this);
 

Code/Framework/AzCore/AzCore/Statistics/StatisticalProfilerProxy.h

@@ -17,154 +17,148 @@
 #include <AzCore/Debug/Profiler.h>
 
 
-#if !defined(AZ_PROFILE_TELEMETRY) && defined(AZ_STATISTICAL_PROFILING_ENABLED)
+#if defined(AZ_STATISTICAL_PROFILING_ENABLED)
 
 #if defined(AZ_PROFILE_SCOPE)
 #undef AZ_PROFILE_SCOPE
 #endif // #if defined(AZ_PROFILE_SCOPE)
 
 #define AZ_PROFILE_SCOPE(profiler, scopeNameId) \
-    static_assert(profiler < AZ::Debug::ProfileCategory::Count, "Invalid profiler category"); \
     static const AZStd::string AZ_JOIN(blockName, __LINE__)(scopeNameId); \
     AZ::Statistics::StatisticalProfilerProxy::TimedScope AZ_JOIN(scope, __LINE__)(profiler, AZ_JOIN(blockName, __LINE__));
 
-#endif //#if !defined(AZ_PROFILE_TELEMETRY)
+#endif //#if defined(AZ_STATISTICAL_PROFILING_ENABLED)
 
-namespace AZ
+namespace AZ::Statistics
 {
-    namespace Statistics
-    {
-        using StatisticalProfilerId = AZ::Debug::ProfileCategory;
+    using StatisticalProfilerId = uint32_t;
 
-        //! This AZ::Interface<> (Yes, it is an application wide singleton) owns an array of StatisticalProfilers.
-        //! When is this useful?
-        //! When you need to statistically profile code that runs across DLL boundaries.
-        //!
-        //! What is the meaning of "statistically profile" code?
-        //! In regular profiling with tools like RAD Telemetry, every execution of a profiled
-        //! scope of code will be captured when using AZ_PROFILE_SCOPE(). You can collect
-        //! very large amounts of data and do your own post processing and analysis in tools like Excel,etc.
-        //! In contrast, "statistical profiling" means that everytime AZ_PROFILE_SCOPE() is called,
-        //! the time spent in the given scope of code will be mathematically accumulated as part of a unique
-        //! Running statistic. Common statistical parameters like min, max, average, variance and standard deviation
-        //! are calculated on the fly. This approach reduces considerably the amount of data that is collected.
-        //! The data is recorded in the Game/Editor Log file.
-        //!
-        //! This StatisticalProfilerProxy should be used via the AZ_PROFILE_SCOPE() macro, and by using
-        //! this macro the developer gains the flexibility of switching at compile time between profiling
-        //! the code via RAD Telemetry or through statistical profiling.
-        //!
-        //! When creating a new statistical profiler add your category (aka profiler id) in Profiler.h (enum class ProfileCategory).
-        //! Get a reference of the statistical profiler with "GetProfiler(const StatisticalProfilerId& id)" using the profiler Id.
-        //! Once you get a reference to the profiler you can customize it, add Running statistics to it, etc.
-        //! Some class in your code will manage the reference to the statistical profiler and will determine
-        //! the policy on how often to log data to the game logs, etc. For example, by subclassing the TickBus Handler, etc.
-        //!
-        //! The StatisticalProfilerProxySystemComponent guarantees that the StatisticalProfilerProxy singleton exists
-        //! as soon as the AZ::Environment is fully initialized.
-        //! See StatisticalProfiler.h for more details and info.
-        class StatisticalProfilerProxy
+    //! This AZ::Interface<> (Yes, it is an application wide singleton) owns an array of StatisticalProfilers.
+    //! When is this useful?
+    //! When you need to statistically profile code that runs across DLL boundaries.
+    //!
+    //! What is the meaning of "statistically profile" code?
+    //! In regular profiling with tools like RAD Telemetry, every execution of a profiled
+    //! scope of code will be captured when using AZ_PROFILE_SCOPE(). You can collect
+    //! very large amounts of data and do your own post processing and analysis in tools like Excel,etc.
+    //! In contrast, "statistical profiling" means that everytime AZ_PROFILE_SCOPE() is called,
+    //! the time spent in the given scope of code will be mathematically accumulated as part of a unique
+    //! Running statistic. Common statistical parameters like min, max, average, variance and standard deviation
+    //! are calculated on the fly. This approach reduces considerably the amount of data that is collected.
+    //! The data is recorded in the Game/Editor Log file.
+    //!
+    //! This StatisticalProfilerProxy should be used via the AZ_PROFILE_SCOPE() macro, and by using
+    //! this macro the developer gains the flexibility of switching at compile time between profiling
+    //! the code via RAD Telemetry or through statistical profiling.
+    //!
+    //! When creating a new statistical profiler add your category (aka profiler id) in Profiler.h (enum class ProfileCategory).
+    //! Get a reference of the statistical profiler with "GetProfiler(const StatisticalProfilerId& id)" using the profiler Id.
+    //! Once you get a reference to the profiler you can customize it, add Running statistics to it, etc.
+    //! Some class in your code will manage the reference to the statistical profiler and will determine
+    //! the policy on how often to log data to the game logs, etc. For example, by subclassing the TickBus Handler, etc.
+    //!
+    //! The StatisticalProfilerProxySystemComponent guarantees that the StatisticalProfilerProxy singleton exists
+    //! as soon as the AZ::Environment is fully initialized.
+    //! See StatisticalProfiler.h for more details and info.
+    class StatisticalProfilerProxy
+    {
+    public:
+        AZ_TYPE_INFO(StatisticalProfilerProxy, "{1103D0EB-1C32-4854-B9D9-40A2D65BDBD2}");
+
+        using StatIdType = AZStd::string;
+        using StatisticalProfilerType = StatisticalProfiler<StatIdType, AZStd::shared_spin_mutex>;
+
+        //! A Convenience class used to measure time performance of scopes of code
+        //! with constructor/destructor. Suitable to be used as part of a macro
+        //! to facilitate its usage.
+        class TimedScope
         {
         public:
-            AZ_TYPE_INFO(StatisticalProfilerProxy, "{1103D0EB-1C32-4854-B9D9-40A2D65BDBD2}");
+            TimedScope() = delete;
 
-            using StatIdType = AZStd::string;
-            using StatisticalProfilerType = StatisticalProfiler<StatIdType, AZStd::shared_spin_mutex>;
-
-            //! A Convenience class used to measure time performance of scopes of code
-            //! with constructor/destructor. Suitable to be used as part of a macro
-            //! to facilitate its usage.
-            class TimedScope
+            TimedScope(const StatisticalProfilerId profilerId, const StatIdType& statId)
+                : m_profilerId(profilerId)
+                , m_statId(statId)
             {
-            public:
-                TimedScope() = delete;
-
-                TimedScope(const StatisticalProfilerId profilerId, const StatIdType& statId)
-                    : m_profilerId(profilerId), m_statId(statId)
-                {
-                    if (!m_profilerProxy)
-                    {
-                        m_profilerProxy = AZ::Interface<StatisticalProfilerProxy>::Get();
-                        if (!m_profilerProxy)
-                        {
-                            return;
-                        }
-                    }
-                    if (!m_profilerProxy->IsProfilerActive(profilerId))
-                    {
-                        return;
-                    }
-                    m_startTime = AZStd::chrono::high_resolution_clock::now();
-                }
-                ~TimedScope()
+                if (!m_profilerProxy)
                 {
+                    m_profilerProxy = AZ::Interface<StatisticalProfilerProxy>::Get();
                     if (!m_profilerProxy)
                     {
                         return;
                     }
-                    AZStd::chrono::system_clock::time_point stopTime = AZStd::chrono::high_resolution_clock::now();
-                    AZStd::chrono::microseconds duration = stopTime - m_startTime;
-                    m_profilerProxy->PushSample(m_profilerId, m_statId, static_cast<double>(duration.count()));
                 }
-
-                //! Required only for UnitTests
-                static void ClearCachedProxy()
+                if (!m_profilerProxy->IsProfilerActive(profilerId))
                 {
-                    m_profilerProxy = nullptr;
+                    return;
                 }
-
-            private:
-                static StatisticalProfilerProxy* m_profilerProxy;
-                const StatisticalProfilerId m_profilerId;
-                const StatIdType& m_statId;
-                AZStd::chrono::system_clock::time_point m_startTime;
-            }; //class TimedScope
-
-            friend class TimedScope;
-
-            StatisticalProfilerProxy()
+                m_startTime = AZStd::chrono::high_resolution_clock::now();
+            }
+            ~TimedScope()
             {
-                m_profilers.reserve(static_cast<AZStd::size_t>(AZ::Debug::ProfileCategory::Count));
-                for (AZStd::size_t i = 0; i < static_cast<AZStd::size_t>(AZ::Debug::ProfileCategory::Count); i++)
+                if (!m_profilerProxy)
                 {
-                    m_profilers.emplace_back(StatisticalProfilerType());
+                    return;
                 }
-                AZ::Interface<StatisticalProfilerProxy>::Register(this);
+                AZStd::chrono::system_clock::time_point stopTime = AZStd::chrono::high_resolution_clock::now();
+                AZStd::chrono::microseconds duration = stopTime - m_startTime;
+                m_profilerProxy->PushSample(m_profilerId, m_statId, static_cast<double>(duration.count()));
             }
 
-            virtual ~StatisticalProfilerProxy()
+            //! Required only for UnitTests
+            static void ClearCachedProxy()
             {
-                AZ::Interface<StatisticalProfilerProxy>::Unregister(this);
-            }
-
-            // Note that you have to delete these for safety reasons, you will trip a static_assert if you do not
-            StatisticalProfilerProxy(StatisticalProfilerProxy&&) = delete;
-            StatisticalProfilerProxy& operator=(StatisticalProfilerProxy&&) = delete;
-
-            bool IsProfilerActive(StatisticalProfilerId id) const
-            {
-                return m_activeProfilersFlag[static_cast<AZStd::size_t>(id)];
-            }
-
-            StatisticalProfilerType& GetProfiler(StatisticalProfilerId id)
-            {
-                return m_profilers[static_cast<AZStd::size_t>(id)];
-            }
-
-            void ActivateProfiler(StatisticalProfilerId id, bool activate)
-            {
-                m_activeProfilersFlag[static_cast<AZStd::size_t>(id)] = activate;
-            }
-
-            void PushSample(StatisticalProfilerId id, const StatIdType& statId, double value)
-            {
-                m_profilers[static_cast<AZStd::size_t>(id)].PushSample(statId, value);
+                m_profilerProxy = nullptr;
             }
 
         private:
-            AZStd::bitset<static_cast<AZStd::size_t>(AZ::Debug::ProfileCategory::Count)> m_activeProfilersFlag;
-            AZStd::vector<StatisticalProfilerType> m_profilers;
-        }; //class StatisticalProfilerProxy
+            static StatisticalProfilerProxy* m_profilerProxy;
+            const StatisticalProfilerId m_profilerId;
+            const StatIdType& m_statId;
+            AZStd::chrono::system_clock::time_point m_startTime;
+        }; // class TimedScope
 
-    }; //namespace Statistics
-}; //namespace AZ
+        friend class TimedScope;
+
+        StatisticalProfilerProxy()
+        {
+            // TODO:BUDGETS Query available budgets at registration time and create an associated profiler per type
+            AZ::Interface<StatisticalProfilerProxy>::Register(this);
+        }
+
+        virtual ~StatisticalProfilerProxy()
+        {
+            AZ::Interface<StatisticalProfilerProxy>::Unregister(this);
+        }
+
+        // Note that you have to delete these for safety reasons, you will trip a static_assert if you do not
+        StatisticalProfilerProxy(StatisticalProfilerProxy&&) = delete;
+        StatisticalProfilerProxy& operator=(StatisticalProfilerProxy&&) = delete;
+
+        bool IsProfilerActive(StatisticalProfilerId id) const
+        {
+            return m_activeProfilersFlag[static_cast<AZStd::size_t>(id)];
+        }
+
+        StatisticalProfilerType& GetProfiler(StatisticalProfilerId id)
+        {
+            return m_profilers[static_cast<AZStd::size_t>(id)];
+        }
+
+        void ActivateProfiler(StatisticalProfilerId id, bool activate)
+        {
+            m_activeProfilersFlag[static_cast<AZStd::size_t>(id)] = activate;
+        }
+
+        void PushSample(StatisticalProfilerId id, const StatIdType& statId, double value)
+        {
+            m_profilers[static_cast<AZStd::size_t>(id)].PushSample(statId, value);
+        }
+
+    private:
+        // TODO:BUDGETS the number of bits allocated here must be based on the number of budgets available at profiler registration time
+        AZStd::bitset<128> m_activeProfilersFlag;
+        AZStd::vector<StatisticalProfilerType> m_profilers;
+    }; // class StatisticalProfilerProxy
+
+}; // namespace AZ::Statistics

Code/Framework/AzCore/AzCore/StringFunc/StringFunc.cpp

@@ -342,8 +342,8 @@ namespace AZ::StringFunc::Internal
         {
             for (const char stripCharacter : stripCharacters)
             {
-                const char lower = tolower(stripCharacter);
-                const char upper = toupper(stripCharacter);
+                const char lower = static_cast<char>(tolower(stripCharacter));
+                const char upper = static_cast<char>(toupper(stripCharacter));
                 if (lower != upper)
                 {
                     combinedStripCharacters.push_back(lower);

Code/Framework/AzCore/AzCore/Task/TaskExecutor.cpp

@@ -41,7 +41,7 @@ namespace AZ
             {
                 Task& task = m_tasks[i];
                 task.m_graph = this;
-                task.m_successorOffset = cursor - m_successors.data();
+                task.m_successorOffset = static_cast<uint32_t>(cursor - m_successors.data());
                 cursor += task.m_outboundLinkCount;
 
                 AZ_Assert(task.m_outboundLinkCount == links[i].size(), "Task outbound link information mismatch");
@@ -78,7 +78,7 @@ namespace AZ
                 return remaining;
             }
 
-            if (m_waitEvent && remaining == (m_parent ? 1 : 0))
+            if (m_waitEvent && remaining == (m_parent ? 1u : 0u))
             {
                 m_waitEvent->Signal();
             }
@@ -259,7 +259,7 @@ namespace AZ
                         }
 
                         bool isRetained = task->m_graph->m_parent != nullptr;
-                        if (task->m_graph->Release() == (isRetained ? 1 : 0))
+                        if (task->m_graph->Release() == (isRetained ? 1u : 0u))
                         {
                             m_executor->ReleaseGraph();
                         }

Code/Framework/AzCore/AzCore/azcore_files.cmake

@@ -25,6 +25,7 @@ set(FILES
     Asset/AssetJsonSerializer.h
     Asset/AssetManager.cpp
     Asset/AssetManager.h
+    Asset/AssetManager_private.h
     Asset/AssetManagerBus.h
     Asset/AssetManagerComponent.cpp
     Asset/AssetManagerComponent.h
@@ -99,8 +100,7 @@ set(FILES
     Debug/FrameProfilerComponent.cpp
     Debug/FrameProfilerComponent.h
     Debug/IEventLogger.h
-    Debug/ProfileModuleInit.cpp
-    Debug/ProfileModuleInit.h
+    Debug/MemoryProfiler.h
     Debug/Profiler.cpp
     Debug/Profiler.h
     Debug/ProfilerBus.h

Code/Framework/AzCore/AzCore/std/delegate/delegate.h

@@ -291,9 +291,7 @@ namespace AZStd
         template <>
         struct SimplifyMemFunc<SINGLE_MEMFUNCPTR_SIZE + 2* sizeof(int) >
         {
-#if defined(AZ_COMPILER_MSVC)
-# pragma warning(push)
-# pragma warning(disable: 4121) // alignment of a member was sensitive to packing
+            AZ_PUSH_DISABLE_WARNING(4121, "-Wunknown-warning-option") // alignment of a member was sensitive to packing
             // GenericClass* (X::*ProbeFunc) changes it's size. From Microsoft:
             //          Jason Shirk [MSFT]
             //          This is a known bug/issue. Unfortunately, we can't fix it in X86 product
@@ -302,7 +300,6 @@ namespace AZStd
             //              We have addressed the issue for all future platforms (including IA64) where
             //              binary compatibility isn't yet an issue.
             // We can fix this warning by adding forward decl class __single_inheritance CLASS; if the XFuncType is member function.
-#endif
             template <class X, class XFuncType, class GenericMemFuncType>
             inline static GenericClass* Convert(X* pthis, XFuncType function_to_bind, GenericMemFuncType& bound_func)
             {
@@ -330,11 +327,7 @@ namespace AZStd
                 u.s.codeptr = u2.s.codeptr;
                 return (pthis->*u.ProbeFunc)();
             }
-
-#if defined(AZ_COMPILER_MSVC)
-# pragma warning(default: 4121) // alignment of a member was sensitive to packing
-# pragma warning(pop)
-#endif
+            AZ_POP_DISABLE_WARNING
         };
 
         // Nasty hack for Microsoft and Intel (IA32 and Itanium)

Code/Framework/AzCore/AzCore/std/function/function_base.h

@@ -20,13 +20,6 @@
 #include <AzCore/std/typetraits/remove_cvref.h>
 #include <AzCore/std/createdestroy.h>
 
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning( push )
-#   pragma warning( disable : 4793 ) // complaint about native code generation
-#   pragma warning( disable : 4127 ) // "conditional expression is constant"
-#   pragma warning( disable : 4275 ) // non dll-interface class 'stdext::exception' used as base for dll-interface class 'std::bad_cast'
-#endif
-
 #define AZSTD_FUNCTION_TARGET_FIX(x)
 #define AZSTD_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, Type)  AZStd::enable_if_t<!std::is_integral_v<Functor>, Type>
 
@@ -796,12 +789,5 @@ namespace AZStd
 //#undef aztypeid
 //#undef aztypeid_cmp
 
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning( default : 4793 ) // complaint about native code generation
-#   pragma warning( default : 4127 ) // "conditional expression is constant"
-#   pragma warning( default : 4275 ) // non dll-interface class 'stdext::exception' used as base for dll-interface class 'std::bad_cast'
-#   pragma warning( pop )
-#endif
-
 #endif // AZSTD_FUNCTION_BASE_HEADER
 #pragma once

Code/Framework/AzCore/AzCore/std/function/function_template.h

@@ -13,11 +13,6 @@
 #include <AzCore/std/typetraits/remove_cvref.h>
 #include <AzCore/std/allocator.h>
 
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning( push )
-#   pragma warning( disable : 4127 ) // "conditional expression is constant"
-#endif
-
 namespace AZStd
 {
     namespace Internal
@@ -689,7 +684,3 @@ namespace AZStd
         }
     };
 } // end namespace AZStd
-
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning( pop )
-#endif

Code/Framework/AzCore/AzCore/std/parallel/containers/internal/concurrent_hash_table.h

@@ -489,24 +489,26 @@ namespace AZStd
                 {
                     return;
                 }
-
-                float loadFactor = (float)m_numElements.load(memory_order_acquire) / (float)m_storage.get_num_buckets();
-                if (loadFactor > max_load_factor())
+                else
                 {
-                    acquire_all();
-
-                    //check the load factor again, as another thread may have beaten us to the rehash
-                    size_type numElements = m_numElements.load(memory_order_acquire);
-                    float maxLoadFactor = max_load_factor();
-                    size_type numBuckets = m_storage.get_num_buckets();
-                    loadFactor = (float)numElements / (float)numBuckets;
-                    if (loadFactor > maxLoadFactor)
+                    float loadFactor = (float)m_numElements.load(memory_order_acquire) / (float)m_storage.get_num_buckets();
+                    if (loadFactor > max_load_factor())
                     {
-                        size_type minNumBuckets = (size_type)((float)numElements / maxLoadFactor);
-                        m_storage.rehash(this, minNumBuckets);
-                    }
+                        acquire_all();
 
-                    release_all();
+                        // check the load factor again, as another thread may have beaten us to the rehash
+                        size_type numElements = m_numElements.load(memory_order_acquire);
+                        float maxLoadFactor = max_load_factor();
+                        size_type numBuckets = m_storage.get_num_buckets();
+                        loadFactor = (float)numElements / (float)numBuckets;
+                        if (loadFactor > maxLoadFactor)
+                        {
+                            size_type minNumBuckets = (size_type)((float)numElements / maxLoadFactor);
+                            m_storage.rehash(this, minNumBuckets);
+                        }
+
+                        release_all();
+                    }
                 }
             }
 

Code/Framework/AzCore/AzCore/std/parallel/spin_mutex.h

@@ -8,7 +8,6 @@
 #ifndef AZSTD_PARALLEL_SPIN_MUTEX_H
 #define AZSTD_PARALLEL_SPIN_MUTEX_H 1
 
-#include <AzCore/Debug/Profiler.h>
 #include <AzCore/std/parallel/atomic.h>
 #include <AzCore/std/parallel/exponential_backoff.h>
 
@@ -32,8 +31,6 @@ namespace AZStd
             bool expected = false;
             if (!m_flag.compare_exchange_weak(expected, true, memory_order_acq_rel, memory_order_acquire))
             {
-                AZ_PROFILE_FUNCTION_STALL(AZ::Debug::ProfileCategory::AzCore);
-
                 exponential_backoff backoff;
                 for (;; )
                 {

Code/Framework/AzCore/AzCore/std/smart_ptr/weak_ptr.h

@@ -192,9 +192,5 @@ namespace AZStd
     }
 } // namespace AZStd
 
-/*#ifdef AZ_COMPILER_MSVC
-# pragma warning(pop)
-#endif */
-
 #endif  // #ifndef AZSTD_SMART_PTR_WEAK_PTR_H
 #pragma once

Code/Framework/AzCore/AzCore/std/string/regex.h

@@ -22,11 +22,6 @@
 // used for std::pointer_traits \note do an AZStd version
 #include <memory>
 
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning(push)
-#   pragma warning(disable: 6011 28198)
-#endif // AZ_COMPILER_MSVC
-
  #ifndef AZ_REGEX_MAX_COMPLEXITY_COUNT
   #define AZ_REGEX_MAX_COMPLEXITY_COUNT 10000000L   /* set to 0 to disable */
  #endif /* AZ_REGEX_MAX_COMPLEXITY_COUNT */
@@ -4766,7 +4761,3 @@ namespace AZStd
         Trans();
     }
 } // namespace AZStd
-
-#if defined(AZ_COMPILER_MSVC)
-#   pragma warning(pop)
-#endif // AZ_COMPILER_MSVC

Code/Framework/AzCore/AzCore/std/string/string_view.h

@@ -7,7 +7,6 @@
  */
 #pragma once
 
-#include <AzCore/Casting/numeric_cast.h>
 #include <AzCore/std/createdestroy.h>
 #include <AzCore/std/iterator.h>
 
@@ -46,6 +45,10 @@ namespace AZStd
                     return npos;
                 }
                 size_t foundIndex = searchIndex + charFindIndex;
+                if (foundIndex + count > size)
+                {
+                    return npos; // the rest of the string doesnt fit in the remainder of the data buffer
+                }
                 if (Traits::compare(&data[foundIndex], ptr, count) == 0)
                 {
                     return foundIndex;