Task00 Алексей Казаков ITMO

src/main.cpp

@@ -65,18 +65,45 @@ int main() {
         // в документации подробно объясняется, какой ситуации соответствует данная ошибка, и это позволит, проверив код, понять, чем же вызвана данная ошибка (некорректным аргументом param_name)
         // Обратите внимание, что в этом же libs/clew/CL/cl.h файле указаны всевоможные defines, такие как CL_DEVICE_TYPE_GPU и т.п.
 
+        // Как и ожидалось, выбрасывает ошибку с кодом -30 (CL_INVALID_VALUE)
+        // OCL_SAFE_CALL(clGetPlatformInfo(platform, 239, 0, nullptr, &platformNameSize));
+
         // TODO 1.2
         // Аналогично тому, как был запрошен список идентификаторов всех платформ - так и с названием платформы, теперь, когда известна длина названия - его можно запросить:
         std::vector<unsigned char> platformName(platformNameSize, 0);
-        // clGetPlatformInfo(...);
+        OCL_SAFE_CALL(clGetPlatformInfo(
+            platform,
+            CL_PLATFORM_NAME,
+            platformName.size() * sizeof(decltype(platformName)::value_type),
+            platformName.data(),
+            nullptr
+        ));
         std::cout << "    Platform name: " << platformName.data() << std::endl;
 
         // TODO 1.3
         // Запросите и напечатайте так же в консоль вендора данной платформы
+        size_t platformVendorSize = 0;
+        OCL_SAFE_CALL(clGetPlatformInfo(platform, CL_PLATFORM_VENDOR, 0, nullptr, &platformVendorSize));
+
+        std::vector<unsigned char> platformVendor(platformVendorSize, 0);
+        OCL_SAFE_CALL(clGetPlatformInfo(platform, CL_PLATFORM_VENDOR, 0, nullptr, &platformVendorSize));
+        OCL_SAFE_CALL(clGetPlatformInfo(
+            platform,
+            CL_PLATFORM_VENDOR,
+            platformVendor.size() * sizeof(decltype(platformVendor)::value_type),
+            platformVendor.data(),
+            nullptr
+        ));
+        std::cout << "    Platform vendor: " << platformVendor.data() << std::endl;
 
         // TODO 2.1
         // Запросите число доступных устройств данной платформы (аналогично тому, как это было сделано для запроса числа доступных платформ - см. секцию "OpenCL Runtime" -> "Query Devices")
         cl_uint devicesCount = 0;
+        OCL_SAFE_CALL(clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, 0, nullptr, &devicesCount));
+        std::cout << "    Devices count: " << devicesCount << std::endl;
+
+        std::vector<cl_device_id> devices(devicesCount);
+        OCL_SAFE_CALL(clGetDeviceIDs(platform, CL_DEVICE_TYPE_ALL, devicesCount, devices.data(), nullptr));
 
         for (int deviceIndex = 0; deviceIndex < devicesCount; ++deviceIndex) {
             // TODO 2.2
@@ -85,6 +112,85 @@ int main() {
             // - Тип устройства (видеокарта/процессор/что-то странное)
             // - Размер памяти устройства в мегабайтах
             // - Еще пару или более свойств устройства, которые вам покажутся наиболее интересными
+
+            cl_device_id device = devices[deviceIndex];
+
+            size_t deviceNameSize = 0;
+            OCL_SAFE_CALL(clGetDeviceInfo(
+                device,
+                CL_DEVICE_NAME,
+                0,
+                nullptr,
+                &deviceNameSize
+            ));
+            std::vector<unsigned char> deviceName(deviceNameSize, 0);
+            OCL_SAFE_CALL(clGetDeviceInfo(
+                device,
+                CL_DEVICE_NAME,
+                deviceName.size() * sizeof(decltype(deviceName)::value_type),
+                deviceName.data(),
+                nullptr
+            ));
+            std::cout << "        Device name: " << deviceName.data() << std::endl;
+
+            cl_device_type deviceType;
+            OCL_SAFE_CALL(clGetDeviceInfo(
+                device,
+                CL_DEVICE_TYPE,
+                sizeof(deviceType),
+                &deviceType,
+                nullptr
+            ));
+            std::string deviceTypeString;
+            if (deviceType & CL_DEVICE_TYPE_CPU) {
+                deviceTypeString += "CPU ";
+            }
+            if (deviceType & CL_DEVICE_TYPE_GPU) {
+                deviceTypeString += "GPU ";
+            }
+            if (deviceType & CL_DEVICE_TYPE_ACCELERATOR) {
+                deviceTypeString += "ACCELERATOR ";
+            }
+            if (deviceType & CL_DEVICE_TYPE_DEFAULT) {
+                deviceTypeString += "DEFAULT ";
+            }
+            std::cout << "        Device type: " << deviceTypeString << std::endl;
+
+            cl_ulong deviceMemorySize = 0;
+            OCL_SAFE_CALL(clGetDeviceInfo(
+                device,
+                CL_DEVICE_GLOBAL_MEM_SIZE,
+                sizeof(deviceMemorySize),
+                &deviceMemorySize,
+                nullptr
+            ));
+            double deviceMemorySizeInMB = deviceMemorySize / (1024.0 * 1024.0);
+            std::cout.precision(2);
+            std::cout << std::fixed;
+            std::cout << "        Memory size: " << deviceMemorySizeInMB << " MB" << std::endl;
+
+            cl_ulong deviceCacheSize;
+            OCL_SAFE_CALL(clGetDeviceInfo(
+                device,
+                CL_DEVICE_GLOBAL_MEM_CACHE_SIZE,
+                sizeof(deviceCacheSize),
+                &deviceCacheSize,
+                nullptr
+            ));
+            double deviceCacheSizeInKB = deviceCacheSize / 1024.0;
+            std::cout.precision(2);
+            std::cout << std::fixed;
+            std::cout << "        Cache size: " << deviceCacheSizeInKB << " KB" << std::endl;
+
+            cl_bool deviceLittleEndian;
+            OCL_SAFE_CALL(clGetDeviceInfo(
+                device,
+                CL_DEVICE_ENDIAN_LITTLE,
+                sizeof(deviceLittleEndian),
+                &deviceLittleEndian,
+                nullptr
+            ));
+            std::cout << "        Endianness: " << (deviceLittleEndian ? "Little" : "Big") << std::endl;
         }
     }