*
* 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 Confidential Information as defined by the
- * Khronos Membership Agreement until designated non-confidential by
- * Khronos, at which point this condition clause shall be removed.
- *
- * 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
case AllocationCallbackRecord::TYPE_ALLOCATION:
{
if (record.data.allocation.returnedPtr)
- {
+ {
if (!de::contains(ptrToSlotIndex, record.data.allocation.returnedPtr))
{
ptrToSlotIndex[record.data.allocation.returnedPtr] = allocations.size();
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;
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;
+ }
}
}
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)