Fix a bug in Graphics Allocations constructors.

- There was a wrong cast in Graphics Allocation constructor resulting
in wrong GPU address generation in some sporadic scenarios.
- Problem appears in 32 bit applications where void* address is cast to
uint64_t value, if c style cast is used it makes trailing bit to be
populated to higher bits constructing wrong value

0xf000000 is being casted to 0xfffffffff0000000 while it should be casted to
0x00000000f0000000
- added special cast function for further use.

Change-Id: I56d53a8e13e17cbacd127566442eea3f6a089977

Author: MichalMrozek

runtime/helpers/ptr_math.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -61,3 +61,7 @@ inline void patchWithRequiredSize(void *memoryToBePatched, uint32_t patchSize, u
         *curbeAddress = (uint32_t)patchValue;
     }
 }
+
+inline uint64_t castToUint64(void *address) {
+    return static_cast<uint64_t>(reinterpret_cast<uintptr_t>(address));
+}

runtime/memory_manager/graphics_allocation.h

@@ -26,6 +26,7 @@
 #include <vector>
 
 #include "runtime/helpers/debug_helpers.h"
+#include "runtime/helpers/ptr_math.h"
 #include "runtime/memory_manager/host_ptr_defines.h"
 #include "runtime/utilities/idlist.h"
 
@@ -69,7 +70,7 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
     GraphicsAllocation(const GraphicsAllocation &) = delete;
     GraphicsAllocation(void *cpuPtrIn, size_t sizeIn) : size(sizeIn),
                                                         cpuPtr(cpuPtrIn),
-                                                        gpuAddress((uint64_t)cpuPtrIn),
+                                                        gpuAddress(castToUint64(cpuPtrIn)),
                                                         sharedHandle(Sharing::nonSharedResource),
 
                                                         allocationType(ALLOCATION_TYPE_UNKNOWN) {}
@@ -83,7 +84,7 @@ class GraphicsAllocation : public IDNode<GraphicsAllocation> {
 
     GraphicsAllocation(void *cpuPtrIn, size_t sizeIn, osHandle sharedHandleIn) : size(sizeIn),
                                                                                  cpuPtr(cpuPtrIn),
-                                                                                 gpuAddress((uint64_t)cpuPtrIn),
+                                                                                 gpuAddress(castToUint64(cpuPtrIn)),
                                                                                  sharedHandle(sharedHandleIn),
 
                                                                                  allocationType(ALLOCATION_TYPE_UNKNOWN) {}

unit_tests/helpers/ptr_math_tests.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2017, Intel Corporation
+ * Copyright (c) 2017 - 2018, Intel Corporation
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -51,3 +51,11 @@ TEST(PtrMath, addrToPtr) {
     EXPECT_EQ(ptr32BitAddr, addrToPtr(addr32Bit));
     EXPECT_EQ(ptr64BitAddr, addrToPtr(addr64Bit));
 }
+
+TEST(PtrMath, givenCastToUint64FunctionWhenItIsCalledThenProperValueIsReturned) {
+    uintptr_t address = 0xf0000000;
+    void *addressWithTrailingBitSet = reinterpret_cast<void *>(address);
+    uint64_t expectedUint64Address = 0xf0000000;
+    auto uintAddress = castToUint64(addressWithTrailingBitSet);
+    EXPECT_EQ(uintAddress, expectedUint64Address);
+}

unit_tests/memory_manager/memory_manager_tests.cpp

@@ -1656,3 +1656,20 @@ TEST_F(MockAlignMallocMemoryManagerTest, givenMemoryManagerWitNonZeroAlignRestri
     uintptr_t memVal = reinterpret_cast<uintptr_t>(alignedMemoryManager->allocateSystemMemory(0x1000, 0x1000));
     EXPECT_EQ(expectedVal, memVal);
 }
+
+TEST(GraphicsAllocation, givenCpuPointerBasedConstructorWhenGraphicsAllocationIsCreatedThenGpuAddressHasCorrectValue) {
+    uintptr_t address = 0xf0000000;
+    void *addressWithTrailingBitSet = reinterpret_cast<void *>(address);
+    uint64_t expectedGpuAddress = 0xf0000000;
+    GraphicsAllocation graphicsAllocation(addressWithTrailingBitSet, 1u);
+    EXPECT_EQ(expectedGpuAddress, graphicsAllocation.getGpuAddress());
+}
+
+TEST(GraphicsAllocation, givenSharedHandleBasedConstructorWhenGraphicsAllocationIsCreatedThenGpuAddressHasCorrectValue) {
+    uintptr_t address = 0xf0000000;
+    void *addressWithTrailingBitSet = reinterpret_cast<void *>(address);
+    uint64_t expectedGpuAddress = 0xf0000000;
+    osHandle sharedHandle{};
+    GraphicsAllocation graphicsAllocation(addressWithTrailingBitSet, 1u, sharedHandle);
+    EXPECT_EQ(expectedGpuAddress, graphicsAllocation.getGpuAddress());
+}