Essentially fixed release build test crash on Mac because of alignment.

Author: singku

aws-cpp-sdk-text-to-speech-tests/RunTests.cpp

@@ -16,21 +16,21 @@
 #include <aws/external/gtest.h>
 #include <aws/core/Aws.h>
 #include <aws/testing/platform/PlatformTesting.h>
-//#include <aws/testing/MemoryTesting.h>
+#include <aws/testing/MemoryTesting.h>
 
 int main(int argc, char** argv)
 {
     Aws::SDKOptions options;
     options.loggingOptions.logLevel = Aws::Utils::Logging::LogLevel::Trace;
-    //AWS_BEGIN_MEMORY_TEST_EX(options, 1024, 128);
+    AWS_BEGIN_MEMORY_TEST_EX(options, 1024, 128);
     Aws::Testing::InitPlatformTest(options);
 
     Aws::InitAPI(options);
     ::testing::InitGoogleTest(&argc, argv);
     int exitCode = RUN_ALL_TESTS(); 
     Aws::ShutdownAPI(options);
 
-    ///AWS_END_MEMORY_TEST_EX;
+    AWS_END_MEMORY_TEST_EX;
     Aws::Testing::ShutdownPlatformTest(options);
     return exitCode;
 }

testing-resources/source/MemoryTesting.cpp

@@ -23,6 +23,10 @@
 #include <chrono>
 #include <thread>
 #include <cstdlib>
+#include <cstddef>
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#define alignof __alignof
+#endif
 
 BaseTestMemorySystem::BaseTestMemorySystem() :
     m_currentBytesAllocated(0),
@@ -47,11 +51,19 @@ void* BaseTestMemorySystem::AllocateMemory(std::size_t blockSize, std::size_t al
     m_maxBytesAllocated = (std::max)(m_maxBytesAllocated, m_currentBytesAllocated);
     m_totalBytesAllocated += blockSize;
 
-    char* rawMemory = reinterpret_cast<char*>(malloc(blockSize + sizeof(std::size_t)));
+    // Note: malloc will always return an address aligned with alignof(std::max_align_t);
+    // This alignment value is not always equals to sizeof(std::size_t). But one thing we can make sure is that
+    // alignof(std::max_align_t) is always multiple of sizeof(std::size_t).
+    // On some platforms, in place construction requires memory address must be aligned with alignof(std::max_align_t).
+    // E.g on Mac, x86_64, sizeof(std::size_t) equals 8. but alignof(std::max_align_t) equals 16. std::function requires aligned memory address.
+    // To record the malloc size and keep returned address align with 16, instead of malloc extra 8 bytes,  
+    // we end up with malloc extra 16 bytes.
+    
+    char* rawMemory = reinterpret_cast<char*>(malloc(blockSize + alignof(std::max_align_t)));
     std::size_t *pointerToSize = reinterpret_cast<std::size_t*>(reinterpret_cast<void*>(rawMemory));
     *pointerToSize = blockSize;
 
-    return reinterpret_cast<void*>(rawMemory + sizeof(std::size_t));
+    return reinterpret_cast<void*>(rawMemory + alignof(std::max_align_t));
 }
 
 void BaseTestMemorySystem::FreeMemory(void* memoryPtr) 
@@ -62,8 +74,7 @@ void BaseTestMemorySystem::FreeMemory(void* memoryPtr)
         --m_currentOutstandingAllocations;
     }
 
-    std::size_t *pointerToSize = reinterpret_cast<std::size_t*>(memoryPtr);
-    --pointerToSize;
+    std::size_t *pointerToSize = reinterpret_cast<std::size_t*>(reinterpret_cast<char*>(memoryPtr) - alignof(std::max_align_t));
     std::size_t blockSize = *pointerToSize;
 
     ASSERT_GE(m_currentBytesAllocated, blockSize);