Merge vk-gl-cts/vulkan-cts-1.0.0 into vk-gl-cts/vulkan-cts-1.0.1

[platform/upstream/VK-GL-CTS.git] / external / vulkancts / framework / vulkan / vkAllocationCallbackUtil.cpp

diff --git a/external/vulkancts/framework/vulkan/vkAllocationCallbackUtil.cpp b/external/vulkancts/framework/vulkan/vkAllocationCallbackUtil.cpp
index e766070..946c087 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkAllocationCallbackUtil.cpp
+++ b/external/vulkancts/framework/vulkan/vkAllocationCallbackUtil.cpp
@@ -4,24 +4,17 @@
  *
  * Copyright (c) 2015 Google Inc.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a
- * copy of this software and/or associated documentation files (the
- * "Materials"), to deal in the Materials without restriction, including
- * without limitation the rights to use, copy, modify, merge, publish,
- * distribute, sublicense, and/or sell copies of the Materials, and to
- * permit persons to whom the Materials are furnished to do so, subject to
- * the following conditions:
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
- * The above copyright notice(s) and this permission notice shall be
- * included in all copies or substantial portions of the Materials.
+ *      http://www.apache.org/licenses/LICENSE-2.0
  *
- * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
- * MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  *
  *//*!
  * \file
@@ -397,7 +390,7 @@ void validateAllocationCallbacks (const AllocationCallbackRecorder& recorder, Al
                        case AllocationCallbackRecord::TYPE_ALLOCATION:
                        {
                                if (record.data.allocation.returnedPtr)
-                               { 
+                               {
                                        if (!de::contains(ptrToSlotIndex, record.data.allocation.returnedPtr))
                                        {
                                                ptrToSlotIndex[record.data.allocation.returnedPtr] = allocations.size();
@@ -406,7 +399,7 @@ void validateAllocationCallbacks (const AllocationCallbackRecorder& recorder, Al
                                        else
                                        {
                                                const size_t            slotNdx         = ptrToSlotIndex[record.data.allocation.returnedPtr];
-                                               if (!allocations[slotNdx].isLive) 
+                                               if (!allocations[slotNdx].isLive)
                                                {
                                                        allocations[slotNdx].isLive = true;
                                                        allocations[slotNdx].record = record;
@@ -489,9 +482,18 @@ void validateAllocationCallbacks (const AllocationCallbackRecorder& recorder, Al
 
                                        if (record.data.reallocation.returnedPtr)
                                        {
-                                               DE_ASSERT(!de::contains(ptrToSlotIndex, record.data.reallocation.returnedPtr));
-                                               ptrToSlotIndex[record.data.reallocation.returnedPtr] = allocations.size();
-                                               allocations.push_back(AllocationSlot(record, true));
+                                               if (!de::contains(ptrToSlotIndex, record.data.reallocation.returnedPtr))
+                                               {
+                                                       ptrToSlotIndex[record.data.reallocation.returnedPtr] = allocations.size();
+                                                       allocations.push_back(AllocationSlot(record, true));
+                                               }
+                                               else
+                                               {
+                                                       const size_t slotNdx = ptrToSlotIndex[record.data.reallocation.returnedPtr];
+                                                       DE_ASSERT(!allocations[slotNdx].isLive);
+                                                       allocations[slotNdx].isLive = true;
+                                                       allocations[slotNdx].record = record;
+                                               }
                                        }
                                }
 
@@ -633,6 +635,34 @@ bool validateAndLog (tcu::TestLog& log, const AllocationCallbackRecorder& record
        return checkAndLog(log, validationResults, allowedLiveAllocScopeBits);
 }
 
+size_t getLiveSystemAllocationTotal (const AllocationCallbackValidationResults& validationResults)
+{
+       size_t  allocationTotal = 0;
+
+       DE_ASSERT(validationResults.violations.empty());
+
+       for (std::vector<AllocationCallbackRecord>::const_iterator alloc = validationResults.liveAllocations.begin();
+                alloc != validationResults.liveAllocations.end();
+                ++alloc)
+       {
+               DE_ASSERT(alloc->type == AllocationCallbackRecord::TYPE_ALLOCATION ||
+                                 alloc->type == AllocationCallbackRecord::TYPE_REALLOCATION);
+
+               const size_t    size            = (alloc->type == AllocationCallbackRecord::TYPE_ALLOCATION ? alloc->data.allocation.size : alloc->data.reallocation.size);
+               const size_t    alignment       = (alloc->type == AllocationCallbackRecord::TYPE_ALLOCATION ? alloc->data.allocation.alignment : alloc->data.reallocation.alignment);
+
+               allocationTotal += size + alignment - (alignment > 0 ? 1 : 0);
+       }
+
+       for (int internalAllocationTypeNdx = 0; internalAllocationTypeNdx < VK_INTERNAL_ALLOCATION_TYPE_LAST; ++internalAllocationTypeNdx)
+       {
+               for (int internalAllocationScopeNdx = 0; internalAllocationScopeNdx < VK_SYSTEM_ALLOCATION_SCOPE_LAST; ++internalAllocationScopeNdx)
+                       allocationTotal += validationResults.internalAllocationTotal[internalAllocationTypeNdx][internalAllocationScopeNdx];
+       }
+
+       return allocationTotal;
+}
+
 std::ostream& operator<< (std::ostream& str, const AllocationCallbackRecord& record)
 {
        switch (record.type)