[clinfo] 121/148: Images, local and constant memory traits
Andreas Beckmann
anbe at moszumanska.debian.org
Mon Nov 17 14:09:54 UTC 2014
This is an automated email from the git hooks/post-receive script.
anbe pushed a commit to branch clinfo
in repository clinfo.
commit c78db5652dcfa702a28748bc416efcee870a36e7
Author: Giuseppe Bilotta <giuseppe.bilotta at gmail.com>
Date: Fri Nov 7 14:34:42 2014 +0100
Images, local and constant memory traits
---
src/clinfo.c | 285 +++++++++++++++++++++++++++++++++++++++++------------------
1 file changed, 200 insertions(+), 85 deletions(-)
diff --git a/src/clinfo.c b/src/clinfo.c
index 7cb8b49..2791c8e 100644
--- a/src/clinfo.c
+++ b/src/clinfo.c
@@ -40,11 +40,13 @@ enum output_modes output_mode = CLINFO_HUMAN;
static const char unk[] = "Unknown";
static const char none[] = "None";
+static const char none_raw[] = "CL_NONE";
static const char na[] = "n/a"; // not available
static const char core[] = "core"; // not available
-static const char fpsupp[] = "Floating-point support";
static const char bytes_str[] = " bytes";
+static const char pixels_str[] = " pixels";
+static const char images_str[] = " images";
static const char* bool_str[] = { "No", "Yes" };
static const char* bool_raw_str[] = { "CL_FALSE", "CL_TRUE" };
@@ -59,11 +61,11 @@ static const char* device_type_raw_str[] = { unk,
static const size_t device_type_str_count = ARRAY_SIZE(device_type_str);
static const char* partition_type_str[] = {
- "none specified", "none", "equally", "by counts", "by affinity domain", "by names (Intel)"
+ "none specified", none, "equally", "by counts", "by affinity domain", "by names (Intel)"
};
static const char* partition_type_raw_str[] = {
"NONE SPECIFIED",
- "NONE",
+ none,
"CL_DEVICE_PARTITION_EQUALLY_EXT",
"CL_DEVICE_PARTITION_BY_COUNTS_EXT",
"CL_DEVICE_PARTITION_BY_AFFINITY_DOMAIN_EXT",
@@ -141,8 +143,10 @@ static const char* memsfx[] = {
const size_t memsfx_count = ARRAY_SIZE(memsfx);
-static const char* local_mem_type_str[] = { none, "Local", "Global" };
+static const char* lmem_type_str[] = { none, "Local", "Global" };
+static const char* lmem_type_raw_str[] = { none_raw, "CL_LOCAL", "CL_GLOBAL" };
static const char* cache_type_str[] = { none, "Read-Only", "Read/Write" };
+static const char* cache_type_raw_str[] = { none_raw, "CL_READ_ONLY_CACHE", "CL_READ_WRITE_CACHE" };
static const char* sources[] = {
"#define GWO(type) global type* restrict\n",
@@ -189,10 +193,9 @@ const char *cur_sfx = empty_str;
static inline
void show_strbuf(const char *pname, int skip)
{
- if (skip)
- printf(I1_STR "%s%s\n", pname, skip_leading_ws(strbuf), cur_sfx);
- else
- printf(I1_STR "%s%s\n", pname, strbuf, cur_sfx);
+ printf(I1_STR "%s%s\n", pname,
+ (skip ? skip_leading_ws(strbuf) : strbuf),
+ had_error ? empty_str : cur_sfx);
}
int
@@ -407,6 +410,9 @@ getOpenCLVersion(const char *version)
struct device_info_checks {
cl_device_type devtype;
+ cl_device_mem_cache_type cachetype;
+ cl_device_local_mem_type lmemtype;
+ cl_bool image_support;
char has_half[12];
char has_double[24];
char has_nv[29];
@@ -472,6 +478,32 @@ int dev_has_partition(const struct device_info_checks *chk)
return dev_is_12(chk) || dev_has_fission(chk);
}
+int dev_has_cache(const struct device_info_checks *chk)
+{
+ return chk->cachetype != CL_NONE;
+}
+
+int dev_has_lmem(const struct device_info_checks *chk)
+{
+ return chk->lmemtype != CL_NONE;
+}
+
+int dev_has_images(const struct device_info_checks *chk)
+{
+ return chk->image_support;
+}
+
+int dev_has_images_12(const struct device_info_checks *chk)
+{
+ return dev_has_images(chk) && dev_is_12(chk);
+}
+
+int dev_has_images_20(const struct device_info_checks *chk)
+{
+ return dev_has_images(chk) && dev_is_20(chk);
+}
+
+
void identify_device_extensions(const char *extensions, struct device_info_checks *chk)
{
#define _HAS_EXT(ext) (strstr(extensions, ext))
@@ -597,8 +629,13 @@ int device_info_bool(cl_device_id dev, cl_device_info param, const char *pname,
GET_VAL;
if (had_error)
show_strbuf(pname, 0);
- else
+ else {
printf(I1_STR "%s%s\n", pname, str[val], cur_sfx);
+ /* abuse strbuf to pass the bool value up to the caller,
+ * this is used e.g. by CL_DEVICE_IMAGE_SUPPORT
+ */
+ memcpy(strbuf, &val, sizeof(val));
+ }
return had_error;
}
@@ -608,7 +645,7 @@ int device_info_bits(cl_device_id dev, cl_device_info param, const char *pname,
cl_uint val;
GET_VAL;
if (!had_error)
- sprintf(strbuf, "%u bits (%u bytes)\n", val, val/8);
+ sprintf(strbuf, "%u bits (%u bytes)", val, val/8);
show_strbuf(pname, 0);
return had_error;
}
@@ -641,6 +678,21 @@ int device_info_mem(cl_device_id dev, cl_device_info param, const char *pname,
return had_error;
}
+int device_info_mem_int(cl_device_id dev, cl_device_info param, const char *pname,
+ const struct device_info_checks *chk)
+{
+ cl_uint val;
+ size_t szval = 0;
+ GET_VAL;
+ if (!had_error) {
+ szval += sprintf(strbuf, "%u", val);
+ if (output_mode == CLINFO_HUMAN && val > 1024)
+ szval += strbuf_mem(val, szval);
+ }
+ show_strbuf(pname, 0);
+ return had_error;
+}
+
int device_info_free_mem_amd(cl_device_id dev, cl_device_info param, const char *pname,
const struct device_info_checks *chk)
{
@@ -661,6 +713,7 @@ int device_info_free_mem_amd(cl_device_id dev, cl_device_info param, const char
}
}
show_strbuf(pname, 0);
+ free(val);
return had_error;
}
@@ -713,6 +766,52 @@ int device_info_wg(cl_device_id dev, cl_device_info param, const char *pname,
return had_error;
}
+int device_info_img_sz_2d(cl_device_id dev, cl_device_info param, const char *pname,
+ const struct device_info_checks *chk)
+{
+ size_t width, height, val;
+ GET_VAL; /* HEIGHT */
+ if (!had_error) {
+ height = val;
+ param = CL_DEVICE_IMAGE2D_MAX_WIDTH;
+ current_param = "CL_DEVICE_IMAGE2D_MAX_WIDTH";
+ GET_VAL;
+ if (!had_error) {
+ width = val;
+ sprintf(strbuf, "%" PRIuS "x%" PRIuS, width, height);
+ }
+ }
+ show_strbuf(pname, 0);
+ return had_error;
+}
+
+int device_info_img_sz_3d(cl_device_id dev, cl_device_info param, const char *pname,
+ const struct device_info_checks *chk)
+{
+ size_t width, height, depth, val;
+ GET_VAL; /* HEIGHT */
+ if (!had_error) {
+ height = val;
+ param = CL_DEVICE_IMAGE3D_MAX_WIDTH;
+ current_param = "CL_DEVICE_IMAGE3D_MAX_WIDTH";
+ GET_VAL;
+ if (!had_error) {
+ width = val;
+ param = CL_DEVICE_IMAGE3D_MAX_DEPTH;
+ current_param = "CL_DEVICE_IMAGE3D_MAX_DEPTH";
+ GET_VAL;
+ if (!had_error) {
+ depth = val;
+ sprintf(strbuf, "%" PRIuS "x%" PRIuS "x%" PRIuS,
+ width, height, depth);
+ }
+ }
+ }
+ show_strbuf(pname, 0);
+ return had_error;
+}
+
+
int device_info_devtype(cl_device_id dev, cl_device_info param, const char *pname,
const struct device_info_checks *chk)
{
@@ -752,6 +851,40 @@ int device_info_devtype(cl_device_id dev, cl_device_info param, const char *pnam
return had_error;
}
+int device_info_cachetype(cl_device_id dev, cl_device_info param, const char *pname,
+ const struct device_info_checks *chk)
+{
+ cl_device_mem_cache_type val;
+ GET_VAL;
+ if (!had_error) {
+ const char * const *ar = (output_mode == CLINFO_HUMAN ?
+ cache_type_str : cache_type_raw_str);
+ sprintf(strbuf, ar[val]);
+ }
+ show_strbuf(pname, 0);
+ /* we abuse global strbuf to pass the cache type over to the caller */
+ if (!had_error)
+ memcpy(strbuf, &val, sizeof(val));
+ return had_error;
+}
+
+int device_info_lmemtype(cl_device_id dev, cl_device_info param, const char *pname,
+ const struct device_info_checks *chk)
+{
+ cl_device_local_mem_type val;
+ GET_VAL;
+ if (!had_error) {
+ const char * const *ar = (output_mode == CLINFO_HUMAN ?
+ lmem_type_str : lmem_type_raw_str);
+ sprintf(strbuf, ar[val]);
+ }
+ show_strbuf(pname, 0);
+ /* we abuse global strbuf to pass the lmem type over to the caller */
+ if (!had_error)
+ memcpy(strbuf, &val, sizeof(val));
+ return had_error;
+}
+
/* stringify a cl_device_topology_amd */
void devtopo_str(const cl_device_topology_amd *devtopo)
{
@@ -1329,14 +1462,57 @@ struct device_info_traits dinfo_traits[] = {
/* Global variables. TODO some 1.2 devices respond to this too */
{ CLINFO_BOTH, DINFO(CL_DEVICE_MAX_GLOBAL_VARIABLE_SIZE, "Max size for global variable", mem), dev_is_20 },
{ CLINFO_BOTH, DINFO(CL_DEVICE_GLOBAL_VARIABLE_PREFERRED_TOTAL_SIZE, "Preferred total size of global vars", mem), dev_is_20 },
+
+ /* Global memory cache */
+ { CLINFO_BOTH, DINFO(CL_DEVICE_GLOBAL_MEM_CACHE_TYPE, "Global Memory cache type", cachetype), NULL },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_GLOBAL_MEM_CACHE_SIZE, "Global Memory cache size", sz), dev_has_cache },
+ { CLINFO_BOTH, DINFO_SFX(CL_DEVICE_GLOBAL_MEM_CACHELINE_SIZE, "Global Memory cache line", " bytes", int), dev_has_cache },
+
+ /* Image support */
+ { CLINFO_BOTH, DINFO(CL_DEVICE_IMAGE_SUPPORT, "Image support", bool), NULL },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_SAMPLERS, INDENT "Max number of samplers per kernel", int), dev_has_images },
+ { CLINFO_BOTH, DINFO_SFX(CL_DEVICE_IMAGE_MAX_BUFFER_SIZE, INDENT "Max size for 1D images from buffer", pixels_str, sz), dev_has_images_12 },
+ { CLINFO_BOTH, DINFO_SFX(CL_DEVICE_IMAGE_MAX_ARRAY_SIZE, INDENT "Max 1D or 2D image array size", images_str, sz), dev_has_images_12 },
+ { CLINFO_BOTH, DINFO_SFX(CL_DEVICE_IMAGE_BASE_ADDRESS_ALIGNMENT, INDENT "Base address alignment for 2D image buffers", bytes_str, sz), dev_has_image2d_buffer },
+ { CLINFO_BOTH, DINFO_SFX(CL_DEVICE_IMAGE_PITCH_ALIGNMENT, INDENT "Pitch alignment for 2D image buffers", bytes_str, sz), dev_has_image2d_buffer },
+
+ /* Image dimensions are split for RAW, combined for HUMAN */
+ { CLINFO_HUMAN, DINFO_SFX(CL_DEVICE_IMAGE2D_MAX_HEIGHT, INDENT "Max 2D image size", pixels_str, img_sz_2d), dev_has_images },
+ { CLINFO_RAW, DINFO(CL_DEVICE_IMAGE2D_MAX_HEIGHT, INDENT "Max 2D image height", sz), dev_has_images },
+ { CLINFO_RAW, DINFO(CL_DEVICE_IMAGE2D_MAX_WIDTH, INDENT "Max 2D image width", sz), dev_has_images },
+ { CLINFO_HUMAN, DINFO_SFX(CL_DEVICE_IMAGE3D_MAX_HEIGHT, INDENT "Max 3D image size", pixels_str, img_sz_3d), dev_has_images },
+ { CLINFO_RAW, DINFO(CL_DEVICE_IMAGE3D_MAX_HEIGHT, INDENT "Max 3D image height", sz), dev_has_images },
+ { CLINFO_RAW, DINFO(CL_DEVICE_IMAGE3D_MAX_WIDTH, INDENT "Max 3D image width", sz), dev_has_images },
+ { CLINFO_RAW, DINFO(CL_DEVICE_IMAGE3D_MAX_DEPTH, INDENT "Max 3D image depth", sz), dev_has_images },
+
+ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_READ_IMAGE_ARGS, INDENT "Max number of read image args", int), dev_has_images },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_WRITE_IMAGE_ARGS, INDENT "Max number of write image args", int), dev_has_images },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_READ_WRITE_IMAGE_ARGS, INDENT "Max number of read/write image args", int), dev_has_images_20 },
+
+ /* Pipes */
+ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_PIPE_ARGS, "Max number of pipe args", int), dev_is_20 },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_PIPE_MAX_ACTIVE_RESERVATIONS, "Max active pipe reservations", int), dev_is_20 },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_PIPE_MAX_PACKET_SIZE, "Max pipe packet size", mem_int), dev_is_20 },
+
+ /* Local memory */
+ { CLINFO_BOTH, DINFO(CL_DEVICE_LOCAL_MEM_TYPE, "Local memory type", lmemtype), NULL },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_LOCAL_MEM_SIZE, "Local memory syze", mem), dev_has_lmem },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD, "Local memory syze per CU (AMD)", mem), dev_is_gpu_amd },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_LOCAL_MEM_BANKS_AMD, "Local memory banks (AMD)", int), dev_is_gpu_amd },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_REGISTERS_PER_BLOCK_NV, "Registers per block (NV)", int), dev_has_nv },
+
+ /* Constant memory */
+ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, "Max constant buffer size", mem), NULL },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_CONSTANT_ARGS, "Max number of constant args", int), NULL },
+
+ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_PARAMETER_SIZE, "Max size of kernel argument", mem), NULL },
+ { CLINFO_BOTH, DINFO(CL_DEVICE_MAX_ATOMIC_COUNTERS_EXT, "Max number of atomic counters", sz), dev_has_atomic_counters },
};
void
printDeviceInfo(cl_uint d)
{
cl_device_id dev = device[d];
- cl_device_local_mem_type lmemtype;
- cl_device_mem_cache_type cachetype;
cl_device_exec_capabilities execap;
cl_command_queue_properties queueprop;
@@ -1346,7 +1522,6 @@ printDeviceInfo(cl_uint d)
double doubleval;
cl_bool boolval;
size_t szval;
- size_t *szvals = calloc(3, sizeof(size_t));
size_t len;
char *extensions = NULL;
@@ -1489,84 +1664,24 @@ printDeviceInfo(cl_uint d)
/* strbuf was abused to give us the dev type */
memcpy(&(chk.devtype), strbuf, sizeof(chk.devtype));
break;
+ case CL_DEVICE_GLOBAL_MEM_CACHE_TYPE:
+ /* strbuf was abused to give us the cache type */
+ memcpy(&(chk.cachetype), strbuf, sizeof(chk.cachetype));
+ break;
+ case CL_DEVICE_LOCAL_MEM_TYPE:
+ /* strbuf was abused to give us the lmem type */
+ memcpy(&(chk.lmemtype), strbuf, sizeof(chk.lmemtype));
+ break;
+ case CL_DEVICE_IMAGE_SUPPORT:
+ /* strbuf was abused to give us boolean value */
+ memcpy(&(chk.image_support), strbuf, sizeof(chk.image_support));
+ break;
default:
/* do nothing */
break;
}
}
- // cache
- GET_PARAM(GLOBAL_MEM_CACHE_TYPE, cachetype);
- STR_PRINT("Global Memory cache type", cache_type_str[cachetype]);
- if (cachetype != CL_NONE) {
- MEM_PARAM(GLOBAL_MEM_CACHE_SIZE, "Global Memory cache size");
- INT_PARAM(GLOBAL_MEM_CACHELINE_SIZE, "Global Memory cache line", " bytes");
- }
-
- // images
- BOOL_PARAM(IMAGE_SUPPORT, "Image support");
- if (boolval) {
- INT_PARAM(MAX_SAMPLERS, INDENT "Max number of samplers per kernel",);
- if (dev_is_12(&chk)) {
- SZ_PARAM(IMAGE_MAX_BUFFER_SIZE, INDENT "Max 1D image size", " pixels");
- SZ_PARAM(IMAGE_MAX_ARRAY_SIZE, INDENT "Max 1D or 2D image array size", " images");
- }
- if (dev_has_image2d_buffer(&chk)) {
- SZ_PARAM(IMAGE_BASE_ADDRESS_ALIGNMENT, INDENT "Base address alignment for 2D image buffers",);
- SZ_PARAM(IMAGE_PITCH_ALIGNMENT, INDENT "Pitch alignment for 2D image buffers",);
- }
- GET_PARAM_PTR(IMAGE2D_MAX_HEIGHT, szvals, 1);
- GET_PARAM_PTR(IMAGE2D_MAX_WIDTH, (szvals+1), 1);
- printf(I2_STR "%" PRIuS "x%" PRIuS " pixels\n", "Max 2D image size",
- szvals[0], szvals[1]);
- GET_PARAM_PTR(IMAGE3D_MAX_HEIGHT, szvals, 1);
- GET_PARAM_PTR(IMAGE3D_MAX_WIDTH, (szvals+1), 1);
- GET_PARAM_PTR(IMAGE3D_MAX_DEPTH, (szvals+2), 1);
- printf(I2_STR "%" PRIuS "x%" PRIuS "x%" PRIuS " pixels\n", "Max 3D image size",
- szvals[0], szvals[1], szvals[2]);
- INT_PARAM(MAX_READ_IMAGE_ARGS, INDENT "Max number of read image args",);
- INT_PARAM(MAX_WRITE_IMAGE_ARGS, INDENT "Max number of write image args",);
- if (dev_is_20(&chk)) {
- INT_PARAM(MAX_READ_WRITE_IMAGE_ARGS, INDENT "Max number of read/write image args",);
- }
- }
-
- // pipes
- if (dev_is_20(&chk)) {
- INT_PARAM(MAX_PIPE_ARGS, "Max number of pipe args", "");
- INT_PARAM(PIPE_MAX_ACTIVE_RESERVATIONS, "Max active pipe reservations", "");
- GET_PARAM(PIPE_MAX_PACKET_SIZE, uintval);
- if (had_error)
- printf(I1_STR "%s\n", "Max pipe packet size", strbuf); \
- else
- MEM_PARAM_STR(uintval, "%u", "Max pipe packet size");
- }
-
-
- // local
- GET_PARAM(LOCAL_MEM_TYPE, lmemtype);
- STR_PRINT("Local memory type", local_mem_type_str[lmemtype]);
- if (lmemtype != CL_NONE)
- MEM_PARAM(LOCAL_MEM_SIZE, "Local memory size");
- if (dev_is_gpu_amd(&chk)) {
- MEM_PARAM(LOCAL_MEM_SIZE_PER_COMPUTE_UNIT_AMD, "Local memory size per CU (AMD)");
- INT_PARAM(LOCAL_MEM_BANKS_AMD, "Local memory banks (AMD)",);
- }
-
- // nv: registers/CU
- if (dev_has_nv(&chk)) {
- INT_PARAM(REGISTERS_PER_BLOCK_NV, "NVIDIA registers per CU",);
- }
-
-
- // constant
- MEM_PARAM(MAX_CONSTANT_BUFFER_SIZE, "Max constant buffer size");
- INT_PARAM(MAX_CONSTANT_ARGS, "Max number of constant args",);
-
- MEM_PARAM(MAX_PARAMETER_SIZE, "Max size of kernel argument");
- if (dev_has_atomic_counters(&chk))
- INT_PARAM(MAX_ATOMIC_COUNTERS_EXT, "Max number of atomic counters",);
-
// queue and kernel capabilities
GET_PARAM(QUEUE_PROPERTIES, queueprop);
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-opencl/clinfo.git
More information about the Pkg-opencl-commits
mailing list