Return error results on validation checks.

src/gpgmm/common/BuddyMemoryAllocator.cpp

@@ -48,13 +48,13 @@ namespace gpgmm {
 
         std::lock_guard<std::mutex> lock(mMutex);
 
-        GPGMM_RETURN_ERROR_IF(!ValidateRequest(request));
+        GPGMM_RETURN_IF_ERROR(ValidateRequest(request));
 
         // Round allocation size to nearest power-of-two.
         const uint64_t allocationSize = UpperPowerOfTwo(request.SizeInBytes);
 
         // Request cannot exceed memory size.
-        GPGMM_RETURN_ERROR_IF(allocationSize > mMemorySize);
+        GPGMM_INVALID_IF(allocationSize > mMemorySize);
 
         // Attempt to sub-allocate a block of the requested size.
         std::unique_ptr<MemoryAllocationBase> subAllocation;

src/gpgmm/common/DedicatedMemoryAllocator.cpp

@@ -33,7 +33,7 @@ namespace gpgmm {
 
         std::lock_guard<std::mutex> lock(mMutex);
 
-        GPGMM_RETURN_ERROR_IF(!ValidateRequest(request));
+        GPGMM_RETURN_IF_ERROR(ValidateRequest(request));
 
         MemoryAllocationRequest memoryRequest = request;
         memoryRequest.Alignment = mMemoryAlignment;

src/gpgmm/common/Error.h

@@ -30,11 +30,21 @@
     for (;;)                                       \
     break
 
-#define GPGMM_RETURN_ERROR_IF(expr) \
-    if (GPGMM_UNLIKELY(expr)) {     \
-        return {};                  \
-    }                               \
-    for (;;)                        \
+#define GPGMM_RETURN_IF_ERROR(expr)                \
+    {                                              \
+        auto result = expr;                        \
+        if (GPGMM_UNLIKELY(!result.IsSuccess())) { \
+            return {};                             \
+        }                                          \
+    }                                              \
+    for (;;)                                       \
+    break
+
+#define GPGMM_INVALID_IF(expr)  \
+    if (GPGMM_UNLIKELY(expr)) { \
+        return {};              \
+    }                           \
+    for (;;)                    \
     break
 
 namespace gpgmm {
@@ -96,6 +106,36 @@ namespace gpgmm {
         ResultT mResult;
     };
 
+    // Specialization of Result<ErrorT, ResultT> where the ResultT is void.
+    // Used when a void function must return a Result with only error code.
+    template <typename ErrorT>
+    class Result<ErrorT, void> {
+      public:
+        Result() : mErrorCode(kInternalSuccessResult) {
+        }
+
+        Result(ErrorT&& error) : mErrorCode(std::move(error)) {
+        }
+
+        Result(Result<ErrorT, void>&& other) : mErrorCode(std::move(other.mErrorCode)) {
+        }
+
+        Result<ErrorT, void>& operator=(Result<ErrorT, void>&& other) {
+            mErrorCode = std::move(other.mErrorCode);
+            return *this;
+        }
+
+        bool IsSuccess() const {
+            return mErrorCode == kInternalSuccessResult;
+        }
+
+      private:
+        ErrorT mErrorCode;
+    };
+
+    // Result with only an error code.
+    using MaybeError = Result<ErrorCodeType, void>;
+
     // Alias of Result + error code to avoid having to always specify error type.
     template <typename ResultT>
     using ResultOrError = Result<ErrorCodeType, ResultT>;

src/gpgmm/common/MemoryAllocator.cpp

@@ -156,15 +156,15 @@ namespace gpgmm {
         return mStats;
     }
 
-    bool MemoryAllocatorBase::ValidateRequest(const MemoryAllocationRequest& request) const {
+    MaybeError MemoryAllocatorBase::ValidateRequest(const MemoryAllocationRequest& request) const {
         ASSERT(request.SizeInBytes > 0 && request.Alignment > 0);
 
         // Check request size cannot overflow.
         if (request.SizeInBytes > std::numeric_limits<uint64_t>::max() - (request.Alignment - 1)) {
             DebugLog(MessageId::kSizeExceeded, false, GetTypename(), this)
                 << "Requested size rejected due to overflow: " + std::to_string(request.SizeInBytes)
                 << " bytes.";
-            return false;
+            return std::move(ErrorCodeType(kInternalFailureResult));
         }
 
         // Check request size cannot overflow |this| memory allocator.
@@ -173,7 +173,7 @@ namespace gpgmm {
             DebugLog(MessageId::kSizeExceeded, false, GetTypename(), this)
                 << "Requested size exceeds memory size (" + std::to_string(alignedSize) + " vs " +
                        std::to_string(GetMemorySize()) + " bytes).";
-            return false;
+            return std::move(ErrorCodeType(kInternalFailureResult));
         }
 
         // Check request size has compatible alignment with |this| memory allocator.
@@ -184,10 +184,10 @@ namespace gpgmm {
                 << "Requested alignment exceeds memory alignment (" +
                        std::to_string(request.Alignment) + " vs " +
                        std::to_string(GetMemoryAlignment()) + " bytes).";
-            return false;
+            return std::move(ErrorCodeType(kInternalFailureResult));
         }
 
-        return true;
+        return {};
     }
 
     MemoryAllocatorBase* MemoryAllocatorBase::GetNextInChain() const {

src/gpgmm/common/MemoryAllocator.h

@@ -192,7 +192,7 @@ namespace gpgmm {
         virtual MemoryAllocatorStats GetStats() const;
 
         // Checks if the request is valid.
-        bool ValidateRequest(const MemoryAllocationRequest& request) const;
+        MaybeError ValidateRequest(const MemoryAllocationRequest& request) const;
 
         // Return the next MemoryAllocatorBase.
         MemoryAllocatorBase* GetNextInChain() const;

src/gpgmm/common/PooledMemoryAllocator.cpp

@@ -42,7 +42,7 @@ namespace gpgmm {
 
         std::lock_guard<std::mutex> lock(mMutex);
 
-        GPGMM_RETURN_ERROR_IF(!ValidateRequest(request));
+        GPGMM_RETURN_IF_ERROR(ValidateRequest(request));
 
         MemoryAllocationBase allocation = mPool->AcquireFromPool();
         if (allocation == GPGMM_INVALID_ALLOCATION) {

src/gpgmm/common/SegmentedMemoryAllocator.cpp

@@ -126,7 +126,7 @@ namespace gpgmm {
 
         std::lock_guard<std::mutex> lock(mMutex);
 
-        GPGMM_RETURN_ERROR_IF(!ValidateRequest(request));
+        GPGMM_RETURN_IF_ERROR(ValidateRequest(request));
 
         const uint64_t memorySize = AlignTo(request.SizeInBytes, mMemoryAlignment);
         MemorySegment* segment = GetOrCreateFreeSegment(memorySize);

src/gpgmm/common/SlabMemoryAllocator.cpp

@@ -202,7 +202,7 @@ namespace gpgmm {
 
         std::lock_guard<std::mutex> lock(mMutex);
 
-        GPGMM_RETURN_ERROR_IF(request.SizeInBytes > mBlockSize);
+        GPGMM_INVALID_IF(request.SizeInBytes > mBlockSize);
 
         uint64_t slabSize =
             ComputeSlabSize(request.SizeInBytes, std::max(mMinSlabSize, mLastUsedSlabSize),
@@ -229,7 +229,7 @@ namespace gpgmm {
                 uint64_t newSlabSize = ComputeSlabSize(
                     request.SizeInBytes, static_cast<uint64_t>(slabSize * mSlabGrowthFactor),
                     request.AvailableForAllocation);
-                GPGMM_RETURN_ERROR_IF(newSlabSize == kInvalidSize);
+                GPGMM_INVALID_IF(newSlabSize == kInvalidSize);
 
                 // If the new slab size exceeds the limit, then re-use the previous, smaller size.
                 if (newSlabSize > mMaxSlabSize) {
@@ -515,10 +515,10 @@ namespace gpgmm {
 
         std::lock_guard<std::mutex> lock(mMutex);
 
-        GPGMM_RETURN_ERROR_IF(!ValidateRequest(request));
+        GPGMM_RETURN_IF_ERROR(ValidateRequest(request));
 
         const uint64_t blockSize = AlignTo(request.SizeInBytes, request.Alignment);
-        GPGMM_RETURN_ERROR_IF(blockSize > mMaxSlabSize);
+        GPGMM_INVALID_IF(blockSize > mMaxSlabSize);
 
         // Create a slab allocator for the new entry.
         auto entry =

src/gpgmm/vk/DeviceMemoryAllocatorVk.cpp

@@ -47,7 +47,7 @@ namespace gpgmm::vk {
             return {};
         }
 
-        GPGMM_RETURN_ERROR_IF(!ValidateRequest(request));
+        GPGMM_RETURN_IF_ERROR(ValidateRequest(request));
 
         VkMemoryAllocateInfo allocateInfo = {};
         allocateInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;