AI/rocm-systems
2
0
Bifurcation 0
Code Tickets Demandes d'ajout Actions Paquets Projets Publications Wiki Activité

[dtest] Enhanced tests for hipGetDeviceCount hipSetDevice and hipGetDevice

Parcourir la source 
Added following functional and negative scenario tests for
HIP_VISIBLE_DEVICES (HVD), ROCR_VISIBLE_DEVICES (RVD)
CUDA_VISIBLE_DEVICES(CVD)
1. Verifying HVD and RVD - invalid number in sequence
2. Verifying HVD and RVD - dupliates in the beginning of sequence
3. Verifying HVD and RVD - all the duplicates
4. Device count with RVD(max devices and HVD(min devices)
5. Device count with RVD(min devices and HVD(max devices)
6. Device count - RVD(set), HVD(unset), CVD(set)

SWDEV-238517 for enhancing hip unit tests

Change-Id: Ia83e9e9068cbf8cc61cff17311cda1d1f8a38fee
Cette révision appartient à :
DURGESH KROTTAPALLI
2020-10-21 19:35:51 +05:30
révisé par Mohan Kumar Mithur
Parent 656a2cb556
révision b2a93adb82
1 fichiers modifiés avec 378 ajouts et 57 suppressions
Télécharger le Fichier Patch Télécharger le Fichier des Différences Développer tous les fichiers Réduire tous les fichiers
hipamd/tests/src/runtimeApi/device/hipSetGetDevice.cpp
+378 -57
Voir le fichier
@@ -25,26 +25,29 @@
*/
/* HIT_START
* BUILD: %t %s ../../test_common.cpp NVCC_OPTIONS -std=c++11 EXCLUDE_HIP_PLATFORM nvidia
* TEST_NAMED: %t hipSetGetDevice-invalidDevice
* TEST_NAMED: %t hipSetGetDevice-allValidDevice
* TEST_NAMED: %t hipSetGetDevice-validDev1 --computeDevCnt 1
* TEST_NAMED: %t hipSetGetDevice-validDev2 --computeDevCnt 2
* TEST_NAMED: %t hipSetGetDevice-validDev3 --computeDevCnt 3
* TEST_NAMED: %t hipSetGetDevice-validDev4 --computeDevCnt 4
* TEST_NAMED: %t hipSetGetDevice-validDev5 --computeDevCnt 5
* TEST_NAMED: %t hipSetGetDevice-validDev6 --computeDevCnt 6
* TEST_NAMED: %t hipSetGetDevice-validDev7 --computeDevCnt 7
* TEST_NAMED: %t hipSetGetDevice-validDev8 --computeDevCnt 8
* BUILD: %t %s ../../test_common.cpp NVCC_OPTIONS -std=c++11
* TEST_NAMED: %t hipSetGetDevice-invalidDevice --tests 1
* TEST_NAMED: %t hipSetGetDevice-allValidDevice --tests 2
* TEST_NAMED: %t hipSetGetDevice-validDev1 --computeDevCnt 1 --tests 4
* TEST_NAMED: %t hipSetGetDevice-validDev2 --computeDevCnt 2 --tests 4
* TEST_NAMED: %t hipSetGetDevice-validDev3 --computeDevCnt 3 --tests 4
* TEST_NAMED: %t hipSetGetDevice-validDev4 --computeDevCnt 4 --tests 4
* TEST_NAMED: %t hipSetGetDevice-validDev5 --computeDevCnt 5 --tests 4
* TEST_NAMED: %t hipSetGetDevice-validDev6 --computeDevCnt 6 --tests 4
* TEST_NAMED: %t hipSetGetDevice-validDev7 --computeDevCnt 7 --tests 4
* TEST_NAMED: %t hipSetGetDevice-validDev8 --computeDevCnt 8 --tests 4
* TEST_NAMED: %t hipSetGetDevice-SetbothEnvVar --tests 5
* HIT_END
*/
#include "test_common.h"
#include <sys/wait.h>
#include <unistd.h>
#include "test_common.h"
int sequence_num = 0;
void getDeviceCount(int *numDevices) {
int fd[2], val = 0;
#ifdef __unix__
pipe(fd);
pid_t childPid;
@@ -60,8 +63,12 @@ void getDeviceCount(int *numDevices) {
int devCnt = 0;
close(fd[0]);
#ifdef __HIP_PLATFORM_NVCC__
unsetenv("CUDA_VISIBLE_DEVICES");
#else
unsetenv("ROCR_VISIBLE_DEVICES");
unsetenv("HIP_VISIBLE_DEVICES");
#endif
hipGetDeviceCount(&devCnt);
@@ -72,6 +79,9 @@ void getDeviceCount(int *numDevices) {
} else {
failed("fork() failed. Exiting the test\n");
}
#else
printf("skipping testcase for non-unix systems\n");
#endif
}
#define MAX_SIZE 30
@@ -84,6 +94,7 @@ bool testInvalidDevice(int numDevices, bool useRocrEnv, int deviceNumber) {
int setDeviceErrorCheck = 0;
int getDeviceErrorCheck = 0;
int getDeviceCountErrorCheck = 0;
#ifdef __unix__
int fd[2];
pipe(fd);
@@ -95,39 +106,34 @@ bool testInvalidDevice(int numDevices, bool useRocrEnv, int deviceNumber) {
if (cPid == 0) { // child
hipError_t err;
#ifdef __HIP_PLATFORM_NVCC__
setenv("CUDA_VISIBLE_DEVICES", visibleDeviceString, 1);
#else
if (true == useRocrEnv) {
setenv("ROCR_VISIBLE_DEVICES", visibleDeviceString, 1);
} else {
setenv("HIP_VISIBLE_DEVICES", visibleDeviceString, 1);
}
#endif
err = hipGetDeviceCount(&tempCount);
if (err == hipErrorNoDevice) {
if (err != hipSuccess) {
getDeviceCountErrorCheck = 1;
} else {
printf("hipGetDeviceCount returns wrong value: %u\n", hipError_t(err));
}
for (int i = 0; i < numDevices; i++) {
err = hipSetDevice(i);
if (err == hipErrorInvalidDevice) {
if (err != hipSuccess) {
setDeviceErrorCheck+= 1;
} else {
printf("hipSetDevice returns wrong value: %u\n", hipError_t(err));
}
err = hipGetDevice(&device);
if (err == hipErrorNoDevice) {
if (err != hipSuccess) {
getDeviceErrorCheck+= 1;
} else {
printf("hipGetDevice returns wrong value: %u\n", hipError_t(err));
}
}
if ((getDeviceCountErrorCheck == 1) && (setDeviceErrorCheck == numDevices)
&& (getDeviceErrorCheck == numDevices)) {
testResult = true;
testResult = true;
} else {
printf("Test failed for invalid device\n");
@@ -149,6 +155,9 @@ bool testInvalidDevice(int numDevices, bool useRocrEnv, int deviceNumber) {
printf("fork() failed\n");
testResult = false;
}
#else
printf("skipping testcase for non-unix systems\n");
#endif
return testResult;
}
@@ -160,18 +169,18 @@ int parseExtraArguments(int argc, char* argv[]) {
if (!strcmp(arg, " ")) {
// skip NULL args.
} else if (!strcmp(arg, "--computeDevCnt")) {
if (++i >= argc || !HipTest::parseInt(argv[i], &deviceListLength)) {
failed("Bad deviceListLength argument");
}
if (++i >= argc || !HipTest::parseInt(argv[i], &deviceListLength)) {
failed("Bad deviceListLength argument");
}
} else {
failed("Bad argument");
failed("Bad argument");
}
}
return i;
}
bool testValidDevices(int numDevices, bool useRocrEnv, int *deviceList,
int deviceListLength) {
int deviceListLength) {
bool testResult = true;
int tempCount = 0;
int device;
@@ -180,9 +189,10 @@ bool testValidDevices(int numDevices, bool useRocrEnv, int *deviceList,
int getDeviceCountErrorCheck = 0;
int *deviceListPtr = deviceList;
char visibleDeviceString[MAX_SIZE] = {};
#ifdef __unix__
if ((NULL == deviceList) || ((deviceListLength < 1) ||
deviceListLength > numDevices)) {
deviceListLength > numDevices)) {
printf("Invalid argument for number of devices. Skipping current test\n");
return testResult;
}
@@ -193,7 +203,7 @@ bool testValidDevices(int numDevices, bool useRocrEnv, int *deviceList,
return testResult;
}
snprintf(visibleDeviceString + strlen(visibleDeviceString), MAX_SIZE, "%d,",
*deviceListPtr++);
*deviceListPtr++);
}
visibleDeviceString[strlen(visibleDeviceString)-1] = 0;
@@ -205,14 +215,19 @@ bool testValidDevices(int numDevices, bool useRocrEnv, int *deviceList,
cPid = fork();
if (cPid == 0) {
#ifdef __HIP_PLATFORM_NVCC__
unsetenv("CUDA_VISIBLE_DEVICES");
setenv("CUDA_VISIBLE_DEVICES", visibleDeviceString, 1);
#else
unsetenv("ROCR_VISIBLE_DEVICES");
unsetenv("HIP_VISIBLE_DEVICES");
if (true == useRocrEnv) {
setenv("ROCR_VISIBLE_DEVICES", visibleDeviceString, 1);
} else {
setenv("HIP_VISIBLE_DEVICES", visibleDeviceString, 1);
}
#endif
hipError_t err;
err = hipGetDeviceCount(&tempCount);
@@ -225,18 +240,18 @@ bool testValidDevices(int numDevices, bool useRocrEnv, int *deviceList,
for (int i = 0; i < numDevices; i++) {
err = hipSetDevice(i);
if (err == hipErrorInvalidDevice) {
if (err != hipSuccess) {
setDeviceErrorCheck+= 1;
}
err = hipGetDevice(&device);
if (err == hipErrorNoDevice) {
if (err != hipSuccess) {
getDeviceErrorCheck+= 1;
}
}
if ((getDeviceCountErrorCheck == 1) && (setDeviceErrorCheck ==
(numDevices-deviceListLength)) && (getDeviceErrorCheck == 0)) {
(numDevices-deviceListLength)) && (getDeviceErrorCheck == 0)) {
testResult = true;
} else {
@@ -259,6 +274,9 @@ bool testValidDevices(int numDevices, bool useRocrEnv, int *deviceList,
printf("fork() failed\n");
testResult = false;
}
#else
printf("skipping testcase for non unix system \n)";
#endif
return testResult;
}
@@ -284,6 +302,250 @@ bool testValidDevicesBasic() {
return testResult;
}
void Initialize(int *deviceList, int numDevices, int count,
char min_visibleDeviceString[], char max_visibleDeviceString[]) {
int *deviceListPtr = deviceList;
for (int i =0; i < count; i++) {
if (i == count-1) {
snprintf(min_visibleDeviceString + strlen(min_visibleDeviceString),
MAX_SIZE, "%d", *deviceListPtr++);
} else {
snprintf(min_visibleDeviceString + strlen(min_visibleDeviceString),
MAX_SIZE, "%d,", *deviceListPtr++);
}
}
for (int i =0; i < numDevices; i++) {
if (i == numDevices-1) {
snprintf(max_visibleDeviceString + strlen(max_visibleDeviceString),
MAX_SIZE, "%d", i);
} else {
snprintf(max_visibleDeviceString + strlen(max_visibleDeviceString),
MAX_SIZE, "%d,", i);
}
}
}
bool testMaxRvdMinHvd(int numDevices, int *deviceList, int count) {
bool testResult = true;
int device;
#ifdef __unix__
int validateCount = 0;
char min_visibleDeviceString[MAX_SIZE] = {0};
char max_visibleDeviceString[MAX_SIZE] = {0};
int fd[2];
pipe(fd);
pid_t cPid;
cPid = fork();
if (cPid == 0) { // child
Initialize(deviceList, numDevices,
count, min_visibleDeviceString, max_visibleDeviceString);
unsetenv("ROCR_VISIBLE_DEVICES");
unsetenv("HIP_VISIBLE_DEVICES");
setenv("ROCR_VISIBLE_DEVICES", max_visibleDeviceString, 1);
setenv("HIP_VISIBLE_DEVICES", min_visibleDeviceString, 1);
HIPCHECK(hipGetDeviceCount(&numDevices));
for (int i = 0; i < numDevices; i++) {
HIPCHECK(hipSetDevice(i));
HIPCHECK(hipGetDevice(&device));
if (device == i) {
validateCount+= 1;
}
}
if (count != validateCount) {
testResult = false;
}
} else if (cPid > 0) {
close(fd[1]);
read(fd[0], &testResult, sizeof(testResult));
close(fd[0]);
wait(NULL);
} else {
printf("fork() failed\n");
testResult = false;
}
#else
printf("skipping testcase for non unix system \n)";
#endif
return testResult;
}
bool testRvdCvd(int numDevices, int *deviceList, int count) {
bool testResult = true;
int device;
#ifdef __unix__
int validateCount = 0;
char min_visibleDeviceString[MAX_SIZE] = {0};
char max_visibleDeviceString[MAX_SIZE] = {0};
int fd[2];
pipe(fd);
pid_t cPid;
cPid = fork();
if (cPid == 0) { // child
Initialize(deviceList, numDevices, count,
min_visibleDeviceString, max_visibleDeviceString);
unsetenv("ROCR_VISIBLE_DEVICES");
unsetenv("HIP_VISIBLE_DEVICES");
setenv("ROCR_VISIBLE_DEVICES", max_visibleDeviceString, 1);
setenv("CUDA_VISIBLE_DEVICES", min_visibleDeviceString, 1);
HIPCHECK(hipGetDeviceCount(&numDevices));
for (int i = 0; i < numDevices; i++) {
HIPCHECK(hipSetDevice(i));
HIPCHECK(hipGetDevice(&device));
if (device == i) {
validateCount+= 1;
}
}
if (count != validateCount) {
testResult = false;
}
} else if (cPid > 0) {
close(fd[1]);
read(fd[0], &testResult, sizeof(testResult));
close(fd[0]);
wait(NULL);
} else {
printf("fork() failed\n");
testResult = false;
}
#else
printf("skipping testcase for non unix system \n)";
#endif
return testResult;
}
bool testMinRvdMaxHvd(int numDevices, int *deviceList, int count) {
bool testResult = true;
int device;
#ifdef __unix__
int validateCount = 0;
char min_visibleDeviceString[MAX_SIZE] = {0};
char max_visibleDeviceString[MAX_SIZE] = {0};
int fd[2];
pipe(fd);
pid_t cPid;
cPid = fork();
if (cPid == 0) { // child
Initialize(deviceList, numDevices, count,
min_visibleDeviceString, max_visibleDeviceString);
unsetenv("ROCR_VISIBLE_DEVICES");
unsetenv("HIP_VISIBLE_DEVICES");
setenv("ROCR_VISIBLE_DEVICES", min_visibleDeviceString, 1);
setenv("HIP_VISIBLE_DEVICES", max_visibleDeviceString, 1);
HIPCHECK(hipGetDeviceCount(&numDevices));
for (int i = 0; i < numDevices; i++) {
HIPCHECK(hipSetDevice(i));
HIPCHECK(hipGetDevice(&device));
if (device == i) {
validateCount+= 1;
}
}
if (count != validateCount) {
testResult = false;
}
close(fd[0]);
write(fd[1], &testResult, sizeof(testResult));
close(fd[1]);
exit(0);
} else if (cPid > 0) {
close(fd[1]);
read(fd[0], &testResult, sizeof(testResult));
close(fd[0]);
wait(NULL);
} else {
printf("fork() failed\n");
testResult = false;
}
#else
printf("skipping testcase for non unix system \n)";
#endif
return testResult;
}
bool testDeviceListSequence(int numDevices, bool useRocrEnv,
int *deviceList, int count) {
bool testResult = true;
#ifdef __unix__
int validateCount = 0;
int device;
char visibleDeviceString[MAX_SIZE] = {0};
int tempCount = 0;
int *deviceListPtr = deviceList;
int fd[2];
if (NULL == deviceList) {
printf("Invalid argument for number of devices. Skipping current test\n");
return testResult;
}
pipe(fd);
pid_t cPid;
cPid = fork();
for (int i =0; i < numDevices; i++) {
if (i == numDevices-1) {
snprintf(visibleDeviceString + strlen(visibleDeviceString),
MAX_SIZE, "%d", *deviceListPtr++);
} else {
snprintf(visibleDeviceString + strlen(visibleDeviceString),
MAX_SIZE, "%d,", *deviceListPtr++);
}
}
if (cPid == 0) { // child
hipError_t err;
#ifdef __HIP_PLATFORM_NVCC__
unsetenv("CUDA_VISIBLE_DEVICES");
setenv("CUDA_VISIBLE_DEVICES", visibleDeviceString, 1);
#else
unsetenv("ROCR_VISIBLE_DEVICES");
unsetenv("HIP_VISIBLE_DEVICES");
if (true == useRocrEnv) {
setenv("ROCR_VISIBLE_DEVICES", visibleDeviceString, 1);
} else {
setenv("HIP_VISIBLE_DEVICES", visibleDeviceString, 1);
}
#endif
err = hipGetDeviceCount(&tempCount);
if (err == hipSuccess) {
for (int i = 0; i < numDevices; i++) {
err = hipSetDevice(i);
if (err == hipSuccess) {
err = hipGetDevice(&device);
if (err == hipSuccess && device == i) {
validateCount += 1;
}
}
}
if (count != tempCount || tempCount != validateCount) {
testResult = false;
} else {
testResult = true;
}
} else {
#ifdef __HIP_PLATFORM_NVCC__
testResult = true;
#endif
}
close(fd[0]);
write(fd[1], &testResult, sizeof(testResult));
close(fd[1]);
exit(0);
} else if (cPid > 0) { // parent
close(fd[1]);
read(fd[0], &testResult, sizeof(testResult));
close(fd[0]);
wait(NULL);
} else {
printf("fork() failed\n");
testResult = false;
}
#else
printf("skipping testcase for non unix system \n)";
#endif
return testResult;
}
int main(int argc, char* argv[]) {
bool testResult = true;
int numDevices = 0;
@@ -302,18 +564,20 @@ int main(int argc, char* argv[]) {
extraArgs = HipTest::parseStandardArguments(argc, argv, false);
parseExtraArguments(extraArgs, argv);
if (extraArgs == 1) {
if (p_tests == 1) {
printf("\nRunning test for invalid compute device\n");
#ifndef __HIP_PLATFORM_NVCC__
// Test setting -1 to ROCR_VISIBLE_DEVICES
testResult &= testInvalidDevice(numDevices, true, -1);
// Test setting -1 to HIP_VISIBLE_DEVICES
testResult &= testInvalidDevice(numDevices, false, -1);
// Test setting invalid device to ROCR_VISIBLE_DEVICES
testResult &= testInvalidDevice(numDevices, true, numDevices);
#endif
// Test setting -1 to HIP_VISIBLE_DEVICES
testResult &= testInvalidDevice(numDevices, false, -1);
// Test setting invalide device to HIP_VISIBLE_DEVICES
testResult &= testInvalidDevice(numDevices, false, numDevices);
} else if (p_tests == 2) {
// Test for all available devices
printf("\nRunning test for all available compute devices\n");
@@ -321,35 +585,92 @@ int main(int argc, char* argv[]) {
deviceList[i] = i;
}
#ifndef __HIP_PLATFORM_NVCC__
testResult &= testValidDevices(numDevices, true, deviceList, numDevices);
#endif
testResult &= testValidDevices(numDevices, false, deviceList, numDevices);
}
// Assigning values to deviceList in reverse order
for (int i=0; i < deviceListLength; i++) {
deviceList[i] = deviceListLength-1-i;
}
// Test for subset of available gpus
if (extraArgs == 3) {
} else if (p_tests == 3) {
printf("Running test for various invalid and valid sequences\n");
int count;
if (numDevices >= 2)
count = 2;
else
count = numDevices;
// Assigning values to deviceList in reverse order
for (int i=0; i < numDevices; i++) {
if (i%2 == 0) {
deviceList[i] = -1;
} else {
deviceList[i] = i;
}
}
#ifndef __HIP_PLATFORM_NVCC__
testResult = testDeviceListSequence(numDevices, true, deviceList, count);
#endif
testResult = testDeviceListSequence(numDevices, false, deviceList, count);
count = 1;
for (int i=0; i < numDevices; i++) {
if (i/2 == 0) {
deviceList[i] = 0;
} else {
deviceList[i] = i;
}
}
#ifndef __HIP_PLATFORM_NVCC__
testResult = testDeviceListSequence(numDevices, true, deviceList, count);
#endif
testResult = testDeviceListSequence(numDevices, false, deviceList, count);
if (numDevices == 1) {
deviceList[0] = 0;
} else {
for (int i=0; i < numDevices; i++) {
deviceList[i] = 1;
}
}
#ifndef __HIP_PLATFORM_NVCC__
testResult &= testDeviceListSequence(numDevices, true, deviceList, count);
#endif
testResult &= testDeviceListSequence(numDevices, false, deviceList, count);
} else if (p_tests == 4) {
// Test for subset of available gpus
for (int i=0; i < deviceListLength; i++) {
deviceList[i] = deviceListLength-1-i;
}
printf("\nRunning test for %d compute devices\n", deviceListLength);
#ifndef __HIP_PLATFORM_NVCC__
testResult &= testValidDevices(numDevices, true, deviceList,
deviceListLength);
deviceListLength);
#endif
testResult &= testValidDevices(numDevices, false, deviceList,
deviceListLength);
deviceListLength);
} else if (p_tests == 5) {
#ifndef __HIP_PLATFORM_NVCC__
int count = 0;
if (numDevices == 1) {
deviceList[0] = 0;
count = 1;
} else {
for (int i=0; i < numDevices; i++) {
if (i%2 == 0) {
deviceList[count] = i;
count++;
}
}
}
testResult &= testMinRvdMaxHvd(numDevices, deviceList, count);
testResult &= testMaxRvdMinHvd(numDevices, deviceList, count);
testResult &= testRvdCvd(numDevices, deviceList, count);
#endif
} else {
failed("Didnt receive any valid option. Try options 1 to 5\n");
}
#else
printf("Running basic test on Windows\n");
testResult &= testValidDevicesBasic();
#endif
if (testResult == true) {
passed();
} else {
failed("One or more tests failed\n");
}