Skip to content

Commit 450be81

Browse files
pbalcerpbalcer
authored
Merge pull request #1943 from kbenzie/benie/fix-coverity-issues
Fix various Coverity defects
2 parents 7f65917 + b33c0e7 commit 450be81

File tree

8 files changed

+60
-60
lines changed

8 files changed

+60
-60
lines changed

‎source/adapters/cuda/memory.hpp

Lines changed: 10 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -197,20 +197,15 @@ struct SurfaceMem {
197197
void *HostPtr)
198198
: Arrays(Context->Devices.size(), CUarray{0}),
199199
SurfObjs(Context->Devices.size(), CUsurfObject{0}),
200-
OuterMemStruct{OuterMemStruct},
201-
ImageFormat{ImageFormat}, ImageDesc{ImageDesc}, HostPtr{HostPtr} {
200+
OuterMemStruct{OuterMemStruct}, ImageDesc{ImageDesc}, ArrayDesc{},
201+
HostPtr{HostPtr} {
202202
// We have to use hipArray3DCreate, which has some caveats. The height and
203203
// depth parameters must be set to 0 produce 1D or 2D arrays. image_desc
204204
// gives a minimum value of 1, so we need to convert the answer.
205205
ArrayDesc.NumChannels = 4; // Only support 4 channel image
206-
ArrayDesc.Flags = 0; // No flags required
207206
ArrayDesc.Width = ImageDesc.width;
208-
if (ImageDesc.type == UR_MEM_TYPE_IMAGE1D) {
209-
ArrayDesc.Height = 0;
210-
ArrayDesc.Depth = 0;
211-
} else if (ImageDesc.type == UR_MEM_TYPE_IMAGE2D) {
207+
if (ImageDesc.type == UR_MEM_TYPE_IMAGE2D) {
212208
ArrayDesc.Height = ImageDesc.height;
213-
ArrayDesc.Depth = 0;
214209
} else if (ImageDesc.type == UR_MEM_TYPE_IMAGE3D) {
215210
ArrayDesc.Height = ImageDesc.height;
216211
ArrayDesc.Depth = ImageDesc.depth;
@@ -414,10 +409,14 @@ struct ur_mem_handle_t_ {
414409
}
415410

416411
ur_result_t clear() {
417-
if (isBuffer()) {
418-
return std::get<BufferMem>(Mem).clear();
412+
try {
413+
if (isBuffer()) {
414+
return std::get<BufferMem>(Mem).clear();
415+
}
416+
return std::get<SurfaceMem>(Mem).clear();
417+
} catch (const ur_result_t &error) {
418+
return error;
419419
}
420-
return std::get<SurfaceMem>(Mem).clear();
421420
}
422421

423422
ur_context_handle_t getContext() const noexcept { return Context; }

‎source/adapters/mock/ur_mock.cpp

Lines changed: 4 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -17,13 +17,14 @@ namespace driver {
1717
context_t d_context;
1818

1919
ur_result_t mock_urPlatformGetApiVersion(void *pParams) {
20-
auto params = *static_cast<ur_platform_get_api_version_params_t *>(pParams);
20+
const auto &params =
21+
*static_cast<ur_platform_get_api_version_params_t *>(pParams);
2122
**params.ppVersion = d_context.version;
2223
return UR_RESULT_SUCCESS;
2324
}
2425

2526
ur_result_t mock_urPlatformGetInfo(void *pParams) {
26-
auto params = *static_cast<ur_platform_get_info_params_t *>(pParams);
27+
const auto &params = *static_cast<ur_platform_get_info_params_t *>(pParams);
2728
if (!*params.phPlatform) {
2829
return UR_RESULT_ERROR_INVALID_NULL_HANDLE;
2930
}
@@ -49,7 +50,7 @@ ur_result_t mock_urPlatformGetInfo(void *pParams) {
4950

5051
//////////////////////////////////////////////////////////////////////////
5152
ur_result_t mock_urDeviceGetInfo(void *pParams) {
52-
auto params = *static_cast<ur_device_get_info_params_t *>(pParams);
53+
const auto &params = *static_cast<ur_device_get_info_params_t *>(pParams);
5354
switch (*params.ppropName) {
5455
case UR_DEVICE_INFO_TYPE:
5556
if (*params.ppPropValue != nullptr) {

‎source/common/ur_util.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -462,7 +462,7 @@ template <typename T> class AtomicSingleton {
462462

463463
static int release(std::function<void(T *)> deleter) {
464464
auto val = instance.acquire();
465-
int ret = val->release(deleter);
465+
int ret = val->release(std::move(deleter));
466466
instance.release();
467467

468468
return ret;

‎source/loader/layers/sanitizer/asan_options.hpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -112,7 +112,7 @@ struct AsanOptions {
112112

113113
KV = OptionsEnvMap->find("redzone");
114114
if (KV != OptionsEnvMap->end()) {
115-
auto Value = KV->second.front();
115+
const auto &Value = KV->second.front();
116116
try {
117117
MinRZSize = std::stoul(Value);
118118
if (MinRZSize < 16) {

‎source/loader/layers/sanitizer/asan_report.cpp

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -32,7 +32,7 @@ void ReportBadFree(uptr Addr, const StackTrace &stack,
3232
(void *)Addr);
3333
}
3434

35-
assert(!AI->IsReleased && "Chunk must be not released");
35+
assert(AI && !AI->IsReleased && "Chunk must be not released");
3636

3737
getContext()->logger.always("{} is located inside of {} region [{}, {})",
3838
(void *)Addr, ToString(AI->Type),

‎source/loader/layers/validation/ur_leak_check.hpp

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -136,6 +136,7 @@ struct RefCountContext {
136136
void clear() { counts.clear(); }
137137

138138
template <typename T> bool isReferenceValid(T handle) {
139+
std::unique_lock<std::mutex> lock(mutex);
139140
auto it = counts.find(static_cast<void *>(handle));
140141
if (it == counts.end() || it->second.refCount < 1) {
141142
return false;

‎test/adapters/level_zero/v2/command_list_cache_test.cpp

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -192,10 +192,10 @@ TEST_P(CommandListCacheTest, CommandListsAreReusedByQueues) {
192192
QueueProps.pNext = &IndexProps;
193193
}
194194

195-
ur_queue_handle_t Queue;
196-
ASSERT_EQ(
197-
urQueueCreate(context, device, &QueueProps, &Queue),
198-
UR_RESULT_SUCCESS);
195+
uur::raii::Queue Queue;
196+
ASSERT_EQ(urQueueCreate(context, device, &QueueProps,
197+
Queue.ptr()),
198+
UR_RESULT_SUCCESS);
199199

200200
Queues.emplace_back(Queue);
201201
}

‎test/conformance/memory/urMemImageCreate.cpp

Lines changed: 38 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -26,10 +26,10 @@ struct urMemImageCreateTest : public uur::urContextTest {
2626
void SetUp() override {
2727
UUR_RETURN_ON_FATAL_FAILURE(uur::urContextTest::SetUp());
2828

29-
ur_mem_handle_t image_handle = nullptr;
29+
uur::raii::Mem image_handle = nullptr;
3030
auto ret =
3131
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE, &image_format,
32-
&image_desc, nullptr, &image_handle);
32+
&image_desc, nullptr, image_handle.ptr());
3333

3434
if (ret == UR_RESULT_ERROR_UNSUPPORTED_FEATURE) {
3535
GTEST_SKIP() << "urMemImageCreate not supported";
@@ -50,10 +50,10 @@ struct urMemImageCreateTestWithParam
5050
UUR_RETURN_ON_FATAL_FAILURE(
5151
uur::urContextTestWithParam<Param>::SetUp());
5252

53-
ur_mem_handle_t image_handle = nullptr;
53+
uur::raii::Mem image_handle = nullptr;
5454
auto ret = urMemImageCreate(this->context, UR_MEM_FLAG_READ_WRITE,
5555
&image_format, &image_desc, nullptr,
56-
&image_handle);
56+
image_handle.ptr());
5757

5858
if (ret == UR_RESULT_ERROR_UNSUPPORTED_FEATURE) {
5959
GTEST_SKIP() << "urMemImageCreate not supported";
@@ -89,12 +89,11 @@ TEST_P(urMemImageCreateTestWith1DMemoryTypeParam, Success) {
8989
0 ///< [in] number of samples
9090
};
9191

92-
ur_mem_handle_t image_handle = nullptr;
92+
uur::raii::Mem image_handle = nullptr;
9393
ASSERT_SUCCESS(urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
9494
&image_format, &image_desc_with_param,
95-
nullptr, &image_handle));
95+
nullptr, image_handle.ptr()));
9696
ASSERT_NE(nullptr, image_handle);
97-
ASSERT_SUCCESS(urMemRelease(image_handle));
9897
}
9998

10099
using urMemImageCreateTestWith2DMemoryTypeParam =
@@ -120,12 +119,11 @@ TEST_P(urMemImageCreateTestWith2DMemoryTypeParam, Success) {
120119
0 ///< [in] number of samples
121120
};
122121

123-
ur_mem_handle_t image_handle = nullptr;
122+
uur::raii::Mem image_handle = nullptr;
124123
ASSERT_SUCCESS(urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
125124
&image_format, &image_desc_with_param,
126-
nullptr, &image_handle));
125+
nullptr, image_handle.ptr()));
127126
ASSERT_NE(nullptr, image_handle);
128-
ASSERT_SUCCESS(urMemRelease(image_handle));
129127
}
130128

131129
TEST_P(urMemImageCreateTest, SuccessWith3DImageType) {
@@ -143,28 +141,27 @@ TEST_P(urMemImageCreateTest, SuccessWith3DImageType) {
143141
0 ///< [in] number of samples
144142
};
145143

146-
ur_mem_handle_t image_handle = nullptr;
144+
uur::raii::Mem image_handle = nullptr;
147145
ASSERT_SUCCESS(urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
148146
&image_format, &image_desc_with_param,
149-
nullptr, &image_handle));
147+
nullptr, image_handle.ptr()));
150148
ASSERT_NE(nullptr, image_handle);
151-
ASSERT_SUCCESS(urMemRelease(image_handle));
152149
}
153150

154151
TEST_P(urMemImageCreateTest, InvalidNullHandleContext) {
155-
ur_mem_handle_t image_handle = nullptr;
152+
uur::raii::Mem image_handle = nullptr;
156153
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
157154
urMemImageCreate(nullptr, UR_MEM_FLAG_READ_WRITE,
158155
&image_format, &image_desc, nullptr,
159-
&image_handle));
156+
image_handle.ptr()));
160157
}
161158

162159
TEST_P(urMemImageCreateTest, InvalidEnumerationFlags) {
163-
ur_mem_handle_t image_handle = nullptr;
160+
uur::raii::Mem image_handle = nullptr;
164161
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_ENUMERATION,
165162
urMemImageCreate(context, UR_MEM_FLAG_FORCE_UINT32,
166163
&image_format, &image_desc, nullptr,
167-
&image_handle));
164+
image_handle.ptr()));
168165
}
169166

170167
TEST_P(urMemImageCreateTest, InvalidNullPointerBuffer) {
@@ -175,117 +172,118 @@ TEST_P(urMemImageCreateTest, InvalidNullPointerBuffer) {
175172
}
176173

177174
TEST_P(urMemImageCreateTest, InvalidNullPointerImageDesc) {
178-
ur_mem_handle_t image_handle = nullptr;
175+
uur::raii::Mem image_handle = nullptr;
179176
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
180177
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
181178
&image_format, nullptr, nullptr,
182-
&image_handle));
179+
image_handle.ptr()));
183180
}
184181

185182
TEST_P(urMemImageCreateTest, InvalidNullPointerImageFormat) {
186-
ur_mem_handle_t image_handle = nullptr;
183+
uur::raii::Mem image_handle = nullptr;
187184
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_POINTER,
188185
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE, nullptr,
189-
&image_desc, nullptr, &image_handle));
186+
&image_desc, nullptr,
187+
image_handle.ptr()));
190188
}
191189

192190
TEST_P(urMemImageCreateTest, InvalidSize) {
193191

194-
ur_mem_handle_t image_handle = nullptr;
192+
uur::raii::Mem image_handle = nullptr;
195193

196194
ur_image_desc_t invalid_image_desc = image_desc;
197195
invalid_image_desc.width = std::numeric_limits<size_t>::max();
198196

199197
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_IMAGE_SIZE,
200198
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
201199
&image_format, &invalid_image_desc,
202-
nullptr, &image_handle));
200+
nullptr, image_handle.ptr()));
203201

204202
invalid_image_desc = image_desc;
205203
invalid_image_desc.height = std::numeric_limits<size_t>::max();
206204

207205
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_IMAGE_SIZE,
208206
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
209207
&image_format, &invalid_image_desc,
210-
nullptr, &image_handle));
208+
nullptr, image_handle.ptr()));
211209

212210
invalid_image_desc = image_desc;
213211
invalid_image_desc.depth = std::numeric_limits<size_t>::max();
214212

215213
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_IMAGE_SIZE,
216214
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
217215
&image_format, &invalid_image_desc,
218-
nullptr, &image_handle));
216+
nullptr, image_handle.ptr()));
219217
}
220218

221219
TEST_P(urMemImageCreateTest, InvalidImageDescStype) {
222-
ur_mem_handle_t image_handle = nullptr;
220+
uur::raii::Mem image_handle = nullptr;
223221
ur_image_desc_t invalid_image_desc = image_desc;
224222
invalid_image_desc.stype = UR_STRUCTURE_TYPE_FORCE_UINT32;
225223
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR,
226224
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
227225
&image_format, &invalid_image_desc,
228-
nullptr, &image_handle));
226+
nullptr, image_handle.ptr()));
229227
}
230228

231229
TEST_P(urMemImageCreateTest, InvalidImageDescType) {
232-
ur_mem_handle_t image_handle = nullptr;
230+
uur::raii::Mem image_handle = nullptr;
233231

234232
ur_image_desc_t invalid_image_desc = image_desc;
235233
invalid_image_desc.type = UR_MEM_TYPE_FORCE_UINT32;
236234

237235
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR,
238236
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
239237
&image_format, &invalid_image_desc,
240-
nullptr, &image_handle));
238+
nullptr, image_handle.ptr()));
241239
}
242240

243241
TEST_P(urMemImageCreateTest, InvalidImageDescNumMipLevel) {
244-
ur_mem_handle_t image_handle = nullptr;
242+
uur::raii::Mem image_handle = nullptr;
245243

246244
ur_image_desc_t invalid_image_desc = image_desc;
247245
invalid_image_desc.numMipLevel = 1; /* Must be 0 */
248246

249247
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR,
250248
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
251249
&image_format, &invalid_image_desc,
252-
nullptr, &image_handle));
250+
nullptr, image_handle.ptr()));
253251
}
254252

255253
TEST_P(urMemImageCreateTest, InvalidImageDescNumSamples) {
256-
ur_mem_handle_t image_handle = nullptr;
254+
uur::raii::Mem image_handle = nullptr;
257255

258256
ur_image_desc_t invalid_image_desc = image_desc;
259257
invalid_image_desc.numSamples = 1; /* Must be 0 */
260258

261259
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR,
262260
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
263261
&image_format, &invalid_image_desc,
264-
nullptr, &image_handle));
262+
nullptr, image_handle.ptr()));
265263
}
266264

267265
TEST_P(urMemImageCreateTest, InvalidImageDescRowPitch) {
268-
ur_mem_handle_t image_handle = nullptr;
266+
uur::raii::Mem image_handle = nullptr;
269267

270268
ur_image_desc_t invalid_image_desc = image_desc;
271269
invalid_image_desc.rowPitch = 1; /* Must be 0 if pHost is NULL */
272270

273271
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR,
274272
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
275273
&image_format, &invalid_image_desc,
276-
nullptr, &image_handle));
274+
nullptr, image_handle.ptr()));
277275
}
278276

279277
TEST_P(urMemImageCreateTest, InvalidImageDescSlicePitch) {
280-
ur_mem_handle_t image_handle = nullptr;
278+
uur::raii::Mem image_handle = nullptr;
281279

282280
ur_image_desc_t invalid_image_desc = image_desc;
283281
invalid_image_desc.slicePitch = 1; /* Must be 0 if pHost is NULL */
284282

285283
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_IMAGE_FORMAT_DESCRIPTOR,
286284
urMemImageCreate(context, UR_MEM_FLAG_READ_WRITE,
287285
&image_format, &invalid_image_desc,
288-
nullptr, &image_handle));
286+
nullptr, image_handle.ptr()));
289287
}
290288

291289
using urMemImageCreateWithHostPtrFlagsTest =
@@ -310,8 +308,9 @@ TEST_P(urMemImageCreateWithHostPtrFlagsTest, Success) {
310308
}
311309

312310
TEST_P(urMemImageCreateWithHostPtrFlagsTest, InvalidHostPtr) {
313-
ur_mem_handle_t image_handle = nullptr;
311+
uur::raii::Mem image_handle = nullptr;
314312
ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_HOST_PTR,
315313
urMemImageCreate(context, getParam(), &image_format,
316-
&image_desc, nullptr, &image_handle));
314+
&image_desc, nullptr,
315+
image_handle.ptr()));
317316
}

0 commit comments

Comments
 (0)