Skip to content

Commit

Permalink
src,test: Fix several signed/unigned MSVC warnings
Browse files Browse the repository at this point in the history
  • Loading branch information
@stotko
stotko committed May 10, 2020
1 parent 302019b commit a7a8350
Show file tree
Hide file tree
Showing 8 changed files with 63 additions and 53 deletions.
4 changes: 2 additions & 2 deletions src/stdgpu/impl/bit_detail.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -63,7 +63,7 @@ popcount(T number)
for (result = 0; number; ++result)
{
// Clear the least significant bit set
number &= number - 1;
number &= number - static_cast<T>(1);
}

STDGPU_ENSURES(0 <= result);
Expand All @@ -79,7 +79,7 @@ template <typename T, typename>
STDGPU_HOST_DEVICE bool
has_single_bit(const T number)
{
return ((number != 0) && !(number & (number - 1)));
return ((number != 0) && !(number & (number - static_cast<T>(1))));
}


Expand Down
8 changes: 4 additions & 4 deletions test/stdgpu/bit.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -302,18 +302,18 @@ TEST_F(stdgpu_bit, popcount_zero)

TEST_F(stdgpu_bit, popcount_pow2)
{
for (std::size_t i = 0; i < std::numeric_limits<std::size_t>::digits; ++i)
for (int i = 0; i < std::numeric_limits<std::size_t>::digits; ++i)
{
EXPECT_EQ(stdgpu::popcount(static_cast<std::size_t>(1) << i), 1);
EXPECT_EQ(stdgpu::popcount(static_cast<std::size_t>(1) << static_cast<std::size_t>(i)), 1);
}
}


TEST_F(stdgpu_bit, popcount_pow2m1)
{
for (std::size_t i = 0; i < std::numeric_limits<std::size_t>::digits; ++i)
for (int i = 0; i < std::numeric_limits<std::size_t>::digits; ++i)
{
EXPECT_EQ(stdgpu::popcount((static_cast<std::size_t>(1) << i) - 1), i);
EXPECT_EQ(stdgpu::popcount((static_cast<std::size_t>(1) << static_cast<std::size_t>(i)) - static_cast<std::size_t>(1)), i);
}
}

Expand Down
2 changes: 1 addition & 1 deletion test/stdgpu/cstdlib.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -55,7 +55,7 @@ thread_values(const stdgpu::index_t iterations)
std::size_t seed = test_utils::random_thread_seed();

std::default_random_engine rng(static_cast<std::default_random_engine::result_type>(seed));
std::uniform_int_distribution<std::size_t> dist_x(1, std::numeric_limits<long long int>::max());
std::uniform_int_distribution<std::size_t> dist_x(1, static_cast<std::size_t>(std::numeric_limits<long long int>::max()));
std::uniform_int_distribution<int> dist_y(1, std::numeric_limits<std::size_t>::digits);

for (stdgpu::index_t i = 0; i < iterations; ++i)
Expand Down
10 changes: 5 additions & 5 deletions test/stdgpu/functional.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -120,7 +120,7 @@ check_integer()
hashes.insert(hasher(i));
}

EXPECT_GT(hashes.size(), N * 90 / 100);
EXPECT_GT(static_cast<stdgpu::index_t>(hashes.size()), N * 90 / 100);
}


Expand Down Expand Up @@ -175,7 +175,7 @@ check_integer_random()
hashes.insert(hasher(dist(rng)));
}

EXPECT_GT(hashes.size(), N * 90 / 100);
EXPECT_GT(static_cast<stdgpu::index_t>(hashes.size()), N * 90 / 100);
}


Expand Down Expand Up @@ -237,7 +237,7 @@ check_floating_point_random()
hashes.insert(hasher(dist(rng)));
}

EXPECT_GT(hashes.size(), N * 90 / 100);
EXPECT_GT(static_cast<stdgpu::index_t>(hashes.size()), N * 90 / 100);
}


Expand Down Expand Up @@ -279,7 +279,7 @@ TEST_F(stdgpu_functional, enum)
hashes.insert(hasher(two));
hashes.insert(hasher(three));

EXPECT_GT(hashes.size(), 4 * 90 / 100);
EXPECT_GT(static_cast<stdgpu::index_t>(hashes.size()), 4 * 90 / 100);
}


Expand All @@ -303,7 +303,7 @@ TEST_F(stdgpu_functional, enum_class)
hashes.insert(hasher(scoped_enum::two));
hashes.insert(hasher(scoped_enum::three));

EXPECT_GT(hashes.size(), 4 * 90 / 100);
EXPECT_GT(static_cast<stdgpu::index_t>(hashes.size()), 4 * 90 / 100);
}


32 changes: 16 additions & 16 deletions test/stdgpu/iterator.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -171,21 +171,21 @@ class insert_iterator<unordered_set<int>>;

TEST_F(stdgpu_iterator, size_device_void)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array = createDeviceArray<int>(size);

EXPECT_EQ(stdgpu::size(reinterpret_cast<void*>(array)), size * sizeof(int));
EXPECT_EQ(stdgpu::size(reinterpret_cast<void*>(array)), size * static_cast<stdgpu::index64_t>(sizeof(int)));

destroyDeviceArray<int>(array);
}


TEST_F(stdgpu_iterator, size_host_void)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array = createHostArray<int>(size);

EXPECT_EQ(stdgpu::size(reinterpret_cast<void*>(array)), size * sizeof(int));
EXPECT_EQ(stdgpu::size(reinterpret_cast<void*>(array)), size * static_cast<stdgpu::index64_t>(sizeof(int)));

destroyHostArray<int>(array);
}
Expand All @@ -194,27 +194,27 @@ TEST_F(stdgpu_iterator, size_host_void)
TEST_F(stdgpu_iterator, size_nullptr_void)
{
int* array = nullptr;
EXPECT_EQ(stdgpu::size(reinterpret_cast<void*>(array)), static_cast<std::size_t>(0));
EXPECT_EQ(stdgpu::size(reinterpret_cast<void*>(array)), static_cast<stdgpu::index64_t>(0));
}


TEST_F(stdgpu_iterator, size_device)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array = createDeviceArray<int>(size);

EXPECT_EQ(stdgpu::size(array), static_cast<std::size_t>(size));
EXPECT_EQ(stdgpu::size(array), size);

destroyDeviceArray<int>(array);
}


TEST_F(stdgpu_iterator, size_host)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array = createHostArray<int>(size);

EXPECT_EQ(stdgpu::size(array), static_cast<std::size_t>(size));
EXPECT_EQ(stdgpu::size(array), size);

destroyHostArray<int>(array);
}
Expand All @@ -223,27 +223,27 @@ TEST_F(stdgpu_iterator, size_host)
TEST_F(stdgpu_iterator, size_nullptr)
{
int* array = nullptr;
EXPECT_EQ(stdgpu::size(array), static_cast<std::size_t>(0));
EXPECT_EQ(stdgpu::size(array), static_cast<stdgpu::index64_t>(0));
}


TEST_F(stdgpu_iterator, size_device_shifted)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array = createDeviceArray<int>(size);

EXPECT_EQ(stdgpu::size(array + 24), static_cast<std::size_t>(0));
EXPECT_EQ(stdgpu::size(array + 24), static_cast<stdgpu::index64_t>(0));

destroyDeviceArray<int>(array);
}


TEST_F(stdgpu_iterator, size_host_shifted)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array_result = createHostArray<int>(size);

EXPECT_EQ(stdgpu::size(array_result + 24), static_cast<std::size_t>(0));
EXPECT_EQ(stdgpu::size(array_result + 24), static_cast<stdgpu::index64_t>(0));

destroyHostArray<int>(array_result);
}
Expand All @@ -253,7 +253,7 @@ TEST_F(stdgpu_iterator, size_device_wrong_alignment)
{
int* array = createDeviceArray<int>(1);

EXPECT_EQ(stdgpu::size(reinterpret_cast<std::size_t*>(array)), static_cast<std::size_t>(0));
EXPECT_EQ(stdgpu::size(reinterpret_cast<std::size_t*>(array)), static_cast<stdgpu::index64_t>(0));

destroyDeviceArray<int>(array);
}
Expand All @@ -263,7 +263,7 @@ TEST_F(stdgpu_iterator, size_host_wrong_alignment)
{
int* array_result = createHostArray<int>(1);

EXPECT_EQ(stdgpu::size(reinterpret_cast<std::size_t*>(array_result)), static_cast<std::size_t>(0));
EXPECT_EQ(stdgpu::size(reinterpret_cast<std::size_t*>(array_result)), static_cast<stdgpu::index64_t>(0));

destroyHostArray<int>(array_result);
}
Expand Down
40 changes: 20 additions & 20 deletions test/stdgpu/memory.inc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -207,7 +207,7 @@ size_bytes<int>(int*);

TEST_F(STDGPU_MEMORY_TEST_CLASS, dynamic_memory_type_device)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array_device = createDeviceArray<int>(size);

EXPECT_EQ(stdgpu::get_dynamic_memory_type(array_device), stdgpu::dynamic_memory_type::device);
Expand All @@ -218,7 +218,7 @@ TEST_F(STDGPU_MEMORY_TEST_CLASS, dynamic_memory_type_device)

TEST_F(STDGPU_MEMORY_TEST_CLASS, dynamic_memory_type_host)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array_host = createHostArray<int>(size);

EXPECT_EQ(stdgpu::get_dynamic_memory_type(array_host), stdgpu::dynamic_memory_type::host);
Expand All @@ -229,7 +229,7 @@ TEST_F(STDGPU_MEMORY_TEST_CLASS, dynamic_memory_type_host)

TEST_F(STDGPU_MEMORY_TEST_CLASS, dynamic_memory_type_managed_on_device)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
const int default_value = 0;
int* array_managed = createManagedArray<int>(size, default_value, Initialization::DEVICE);

Expand All @@ -241,7 +241,7 @@ TEST_F(STDGPU_MEMORY_TEST_CLASS, dynamic_memory_type_managed_on_device)

TEST_F(STDGPU_MEMORY_TEST_CLASS, dynamic_memory_type_managed_on_host)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
const int default_value = 0;
int* array_managed = createManagedArray<int>(size, default_value, Initialization::HOST);

Expand Down Expand Up @@ -276,45 +276,45 @@ TEST_F(STDGPU_MEMORY_TEST_CLASS, dynamic_memory_type_nullptr)

TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_device)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array_device = createDeviceArray<int>(size);

EXPECT_EQ(stdgpu::size_bytes(array_device), size * sizeof(int));
EXPECT_EQ(stdgpu::size_bytes(array_device), size * static_cast<stdgpu::index64_t>(sizeof(int)));

destroyDeviceArray<int>(array_device);
}


TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_host)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array_host = createHostArray<int>(size);

EXPECT_EQ(stdgpu::size_bytes(array_host), size * sizeof(int));
EXPECT_EQ(stdgpu::size_bytes(array_host), size * static_cast<stdgpu::index64_t>(sizeof(int)));

destroyHostArray<int>(array_host);
}


TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_managed_device)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
const int default_value = 0;
int* array_managed = createManagedArray<int>(size, default_value, Initialization::DEVICE);

EXPECT_EQ(stdgpu::size_bytes(array_managed), size * sizeof(int));
EXPECT_EQ(stdgpu::size_bytes(array_managed), size * static_cast<stdgpu::index64_t>(sizeof(int)));

destroyManagedArray<int>(array_managed);
}


TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_manged_host)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
const int default_value = 0;
int* array_managed = createManagedArray<int>(size, default_value, Initialization::HOST);

EXPECT_EQ(stdgpu::size_bytes(array_managed), size * sizeof(int));
EXPECT_EQ(stdgpu::size_bytes(array_managed), size * static_cast<stdgpu::index64_t>(sizeof(int)));

destroyManagedArray<int>(array_managed);
}
Expand All @@ -328,10 +328,10 @@ TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_nullptr)

TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_device_shifted)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array_device = createDeviceArray<int>(size);

const stdgpu::index_t offset = 24;
const stdgpu::index64_t offset = 24;
EXPECT_EQ(stdgpu::size_bytes(array_device + offset), static_cast<stdgpu::index64_t>(0));

destroyDeviceArray<int>(array_device);
Expand All @@ -340,10 +340,10 @@ TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_device_shifted)

TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_host_shifted)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
int* array_host = createHostArray<int>(size);

const stdgpu::index_t offset = 24;
const stdgpu::index64_t offset = 24;
EXPECT_EQ(stdgpu::size_bytes(array_host + offset), static_cast<stdgpu::index64_t>(0));

destroyHostArray<int>(array_host);
Expand All @@ -352,11 +352,11 @@ TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_host_shifted)

TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_managed_device_shifted)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
const int default_value = 0;
int* array_managed = createManagedArray<int>(size, default_value, Initialization::DEVICE);

const stdgpu::index_t offset = 24;
const stdgpu::index64_t offset = 24;
EXPECT_EQ(stdgpu::size_bytes(array_managed + offset), static_cast<stdgpu::index64_t>(0));

destroyManagedArray<int>(array_managed);
Expand All @@ -365,11 +365,11 @@ TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_managed_device_shifted)

TEST_F(STDGPU_MEMORY_TEST_CLASS, size_bytes_managed_host_shifted)
{
const stdgpu::index_t size = 42;
const stdgpu::index64_t size = 42;
const int default_value = 0;
int* array_managed = createManagedArray<int>(size, default_value, Initialization::HOST);

const stdgpu::index_t offset = 24;
const stdgpu::index64_t offset = 24;
EXPECT_EQ(stdgpu::size_bytes(array_managed + offset), static_cast<stdgpu::index64_t>(0));

destroyManagedArray<int>(array_managed);
Expand Down
12 changes: 11 additions & 1 deletion test/stdgpu/mutex.inc
View file
Original file line number Diff line number Diff line change
Expand Up @@ -127,6 +127,16 @@ class same_state
};


struct check_flag
{
STDGPU_DEVICE_ONLY bool
operator()(const std::uint8_t flag) const
{
return static_cast<bool>(flag);
}
};


bool
equal(const stdgpu::mutex_array& locks_1,
const stdgpu::mutex_array& locks_2)
Expand All @@ -143,7 +153,7 @@ equal(const stdgpu::mutex_array& locks_1,
same_state(locks_1, locks_2));

bool result = thrust::all_of(stdgpu::device_cbegin(equality_flags), stdgpu::device_cend(equality_flags),
thrust::identity<bool>());
check_flag());

destroyDeviceArray<std::uint8_t>(equality_flags);

Expand Down
Loading

0 comments on commit a7a8350

Please sign in to comment.