OpenCL-CTS/test_conformance/api/test_platform.cpp

//
// Copyright (c) 2017 The Khronos Group Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#include "testBase.h"

#include <string.h>

#define EXTENSION_NAME_BUF_SIZE 4096

#define PRINT_EXTENSION_INFO 0

int test_platform_extensions(cl_device_id deviceID, cl_context context,
                 cl_command_queue queue, int num_elements)
{
    const char * extensions[] = {
    "cl_khr_byte_addressable_store",
//    "cl_APPLE_SetMemObjectDestructor",
    "cl_khr_global_int32_base_atomics",
    "cl_khr_global_int32_extended_atomics",
    "cl_khr_local_int32_base_atomics",
    "cl_khr_local_int32_extended_atomics",
    "cl_khr_int64_base_atomics",
    "cl_khr_int64_extended_atomics",
// need to put in entires for various atomics
    "cl_khr_3d_image_writes",
    "cl_khr_fp16",
    "cl_khr_fp64",
    NULL
    };

    bool extensionsSupported[] = {
    false, //"cl_khr_byte_addressable_store",
    false, // need to put in entires for various atomics
    false, // "cl_khr_global_int32_base_atomics",
    false, // "cl_khr_global_int32_extended_atomics",
    false, // "cl_khr_local_int32_base_atomics",
    false, // "cl_khr_local_int32_extended_atomics",
    false, // "cl_khr_int64_base_atomics",
    false, // "cl_khr_int64_extended_atomics",
    false, //"cl_khr_3d_image_writes",
    false, //"cl_khr_fp16",
    false, //"cl_khr_fp64",
    false //NULL
    };

    int extensionIndex;

    cl_platform_id platformID;
    cl_int err;

    char platform_extensions[EXTENSION_NAME_BUF_SIZE];
    char device_extensions[EXTENSION_NAME_BUF_SIZE];

    // Okay, so what we're going to do is just check the device indicated by
    // deviceID against the platform that includes this device


    // pass CL_DEVICE_PLATFORM to clGetDeviceInfo
    // to get a result of type cl_platform_id

    err = clGetDeviceInfo(deviceID,
              CL_DEVICE_PLATFORM,
              sizeof(cl_platform_id),
              (void *)(&platformID),
              NULL);

    if(err != CL_SUCCESS)
    {
    vlog_error("test_platform_extensions : could not get platformID from device\n");
    return -1;
    }


    // now we grab the set of extensions specified by the platform
    err = clGetPlatformInfo(platformID,
                CL_PLATFORM_EXTENSIONS,
                sizeof(platform_extensions),
                (void *)(&platform_extensions[0]),
                NULL);
    if(err != CL_SUCCESS)
    {
    vlog_error("test_platform_extensions : could not get extension string from platform\n");
    return -1;
    }

#if PRINT_EXTENSION_INFO
    log_info("Platform extensions include \"%s\"\n\n", platform_extensions);
#endif

    // here we parse the platform extensions, to look for the "important" ones
    for(extensionIndex=0; extensions[extensionIndex] != NULL; ++extensionIndex)
    {
    if(strstr(platform_extensions, extensions[extensionIndex]) != NULL)
    {
        // we found it
#if PRINT_EXTENSION_INFO
        log_info("Found \"%s\" in platform extensions\n",
        extensions[extensionIndex]);
#endif
        extensionsSupported[extensionIndex] = true;
    }
    }

    // and then we grab the set of extensions specified by the device
    // (this can be turned into a "loop over all devices in this platform")
    err = clGetDeviceInfo(deviceID,
              CL_DEVICE_EXTENSIONS,
              sizeof(device_extensions),
              (void *)(&device_extensions[0]),
              NULL);
    if(err != CL_SUCCESS)
    {
    vlog_error("test_platform_extensions : could not get extension string from device\n");
    return -1;
    }


#if PRINT_EXTENSION_INFO
    log_info("Device extensions include \"%s\"\n\n", device_extensions);
#endif

    for(extensionIndex=0; extensions[extensionIndex] != NULL; ++extensionIndex)
    {
    if(extensionsSupported[extensionIndex] == false)
    {
        continue; // skip this one
    }

    if(strstr(device_extensions, extensions[extensionIndex]) == NULL)
    {
        // device does not support it
        vlog_error("Platform supports extension \"%s\" but device does not\n",
               extensions[extensionIndex]);
        return -1;
    }
    }
    return 0;
}

int test_get_platform_ids(cl_device_id deviceID, cl_context context, cl_command_queue queue, int num_elements) {
  cl_platform_id platforms[16];
  cl_uint num_platforms;
  char *string_returned;

  string_returned = (char*)malloc(8192);

  int total_errors = 0;
  int err = CL_SUCCESS;


  err = clGetPlatformIDs(16, platforms, &num_platforms);
  test_error(err, "clGetPlatformIDs failed");

  if (num_platforms <= 16) {
    // Try with NULL
    err = clGetPlatformIDs(num_platforms, platforms, NULL);
    test_error(err, "clGetPlatformIDs failed with NULL for return size");
  }

  if (num_platforms < 1) {
    log_error("Found 0 platforms.\n");
    return -1;
  }
  log_info("Found %d platforms.\n", num_platforms);


  for (int p=0; p<(int)num_platforms; p++) {
    cl_device_id *devices;
    cl_uint num_devices;
    size_t size;


    log_info("Platform %d (%p):\n", p, platforms[p]);

    memset(string_returned, 0, 8192);
    err = clGetPlatformInfo(platforms[p], CL_PLATFORM_PROFILE, 8192, string_returned, &size);
    test_error(err, "clGetPlatformInfo for CL_PLATFORM_PROFILE failed");
    log_info("\tCL_PLATFORM_PROFILE: %s\n", string_returned);
    if (strlen(string_returned)+1 != size) {
      log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size);
      total_errors++;
    }

    memset(string_returned, 0, 8192);
    err = clGetPlatformInfo(platforms[p], CL_PLATFORM_VERSION, 8192, string_returned, &size);
    test_error(err, "clGetPlatformInfo for CL_PLATFORM_VERSION failed");
    log_info("\tCL_PLATFORM_VERSION: %s\n", string_returned);
    if (strlen(string_returned)+1 != size) {
      log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size);
      total_errors++;
    }

    memset(string_returned, 0, 8192);
    err = clGetPlatformInfo(platforms[p], CL_PLATFORM_NAME, 8192, string_returned, &size);
    test_error(err, "clGetPlatformInfo for CL_PLATFORM_NAME failed");
    log_info("\tCL_PLATFORM_NAME: %s\n", string_returned);
    if (strlen(string_returned)+1 != size) {
      log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size);
      total_errors++;
    }

    memset(string_returned, 0, 8192);
    err = clGetPlatformInfo(platforms[p], CL_PLATFORM_VENDOR, 8192, string_returned, &size);
    test_error(err, "clGetPlatformInfo for CL_PLATFORM_VENDOR failed");
    log_info("\tCL_PLATFORM_VENDOR: %s\n", string_returned);
    if (strlen(string_returned)+1 != size) {
      log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size);
      total_errors++;
    }

    memset(string_returned, 0, 8192);
    err = clGetPlatformInfo(platforms[p], CL_PLATFORM_EXTENSIONS, 8192, string_returned, &size);
    test_error(err, "clGetPlatformInfo for CL_PLATFORM_EXTENSIONS failed");
    log_info("\tCL_PLATFORM_EXTENSIONS: %s\n", string_returned);
    if (strlen(string_returned)+1 != size) {
      log_error("Returned string length %ld does not equal reported one %ld.\n", strlen(string_returned)+1, size);
      total_errors++;
    }

    err = clGetDeviceIDs(platforms[p], CL_DEVICE_TYPE_ALL, 0, NULL, &num_devices);
    test_error(err, "clGetDeviceIDs size failed.\n");
    devices = (cl_device_id *)malloc(num_devices*sizeof(cl_device_id));
    memset(devices, 0, sizeof(cl_device_id)*num_devices);
    err = clGetDeviceIDs(platforms[p], CL_DEVICE_TYPE_ALL, num_devices, devices, NULL);
    test_error(err, "clGetDeviceIDs failed.\n");

    log_info("\tPlatform has %d devices.\n", (int)num_devices);
    for (int d=0; d<(int)num_devices; d++) {
      size_t returned_size;
      cl_platform_id returned_platform;
      cl_context context;
      cl_context_properties properties[] = { CL_CONTEXT_PLATFORM, (cl_context_properties)platforms[p], 0 };

      err = clGetDeviceInfo(devices[d], CL_DEVICE_PLATFORM, sizeof(cl_platform_id), &returned_platform, &returned_size);
      test_error(err, "clGetDeviceInfo failed for CL_DEVICE_PLATFORM\n");
      if (returned_size != sizeof(cl_platform_id)) {
        log_error("Reported return size (%ld) does not match expected size (%ld).\n", returned_size, sizeof(cl_platform_id));
        total_errors++;
      }

      memset(string_returned, 0, 8192);
      err = clGetDeviceInfo(devices[d], CL_DEVICE_NAME, 8192, string_returned, NULL);
      test_error(err, "clGetDeviceInfo failed for CL_DEVICE_NAME\n");

      log_info("\t\tPlatform for device %d (%s) is %p.\n", d, string_returned, returned_platform);

      log_info("\t\t\tTesting clCreateContext for the platform/device...\n");
      // Try creating a context for the platform
      context = clCreateContext(properties, 1, &devices[d], NULL, NULL, &err);
      test_error(err, "\t\tclCreateContext failed for device with platform properties\n");

      memset(properties, 0, sizeof(cl_context_properties)*3);

      err = clGetContextInfo(context, CL_CONTEXT_PROPERTIES, sizeof(cl_context_properties)*3, properties, &returned_size);
      test_error(err, "clGetContextInfo for CL_CONTEXT_PROPERTIES failed");
      if (returned_size != sizeof(cl_context_properties)*3) {
        log_error("Invalid size returned from clGetContextInfo for CL_CONTEXT_PROPERTIES. Got %ld, expected %ld.\n",
                  returned_size, sizeof(cl_context_properties)*3);
        total_errors++;
      }

      if (properties[0] != (cl_context_properties)CL_CONTEXT_PLATFORM || properties[1] != (cl_context_properties)platforms[p]) {
        log_error("Wrong properties returned. Expected: [%p %p], got [%p %p]\n",
                  (void*)CL_CONTEXT_PLATFORM, platforms[p], (void*)properties[0], (void*)properties[1]);
        total_errors++;
      }

      err = clReleaseContext(context);
      test_error(err, "clReleaseContext failed");
    }
    free(devices);
  }

  free(string_returned);

  return total_errors;
}