/perf/kseta

To get this branch, use:
bzr branch http://darksoft.org/webbzr/perf/kseta

« back to all changes in this revision

Viewing changes to sources/tools/cl_info.c

  • Committer: Suren A. Chilingaryan
  • Date: 2013-09-30 06:47:09 UTC
  • Revision ID: csa@dside.dyndns.org-20130930064709-55cde0k5ci76t8z5
Simple matrix multiplication

Show diffs side-by-side

added added

removed removed

Lines of Context:
sources/tools/cl_info.c
 
1
#include <stdio.h>
 
2
#include <stdlib.h>
 
3
#include <string.h>
 
4
 
 
5
#include <CL/cl.h>
 
6
 
 
7
#define SUPPORTED_PLATFORMS 4
 
8
#define SUPPORTED_DEVICES 16
 
9
#define MAX_PARAM_SIZE 1024
 
10
 
 
11
int main() {
 
12
    cl_int err;
 
13
    cl_int i, j, k;
 
14
    cl_uint dim;
 
15
 
 
16
    cl_uint num_platforms;
 
17
    cl_platform_id platforms[SUPPORTED_PLATFORMS];
 
18
 
 
19
    cl_uint num_devices;
 
20
    cl_device_id devices[SUPPORTED_DEVICES];
 
21
 
 
22
    char param[MAX_PARAM_SIZE];
 
23
    
 
24
    err = clGetPlatformIDs(SUPPORTED_PLATFORMS, platforms, &num_platforms);
 
25
    if (err != CL_SUCCESS) {
 
26
        printf("Can't identify platforms");
 
27
        exit(0);
 
28
    }
 
29
    
 
30
    for (i = 0; i < num_platforms; i++) {
 
31
        err = clGetPlatformInfo (platforms[i], CL_PLATFORM_NAME, sizeof(param), param, NULL);
 
32
        if (err != CL_SUCCESS) {
 
33
            puts("Unidentified platform");
 
34
            continue;
 
35
        } else printf("Platform: %s", param);
 
36
 
 
37
        err = clGetPlatformInfo (platforms[i], CL_PLATFORM_VERSION, sizeof(param), param, NULL);
 
38
        if (err == CL_SUCCESS) {
 
39
            printf(", Version: %s", param);
 
40
        }
 
41
 
 
42
        err = clGetPlatformInfo (platforms[i], CL_PLATFORM_PROFILE, sizeof(param), param, NULL);
 
43
        if (err == CL_SUCCESS) {
 
44
            printf(", Profile: %s", param);
 
45
        }
 
46
        
 
47
        printf("\n");
 
48
        
 
49
        err = clGetDeviceIDs (platforms[i], CL_DEVICE_TYPE_ALL, SUPPORTED_DEVICES, devices, &num_devices);
 
50
        if (err != CL_SUCCESS) {
 
51
            puts(" Device enumeration failed");
 
52
            continue;
 
53
        }
 
54
        
 
55
        for (j = 0; j < num_devices; j++) {
 
56
            err = clGetDeviceInfo(devices[j], CL_DEVICE_TYPE, sizeof(param), param, NULL);
 
57
            if (err != CL_SUCCESS) {
 
58
                puts(" Unknown device");
 
59
                continue;
 
60
            }
 
61
 
 
62
            switch (*param&(CL_DEVICE_TYPE_CPU|CL_DEVICE_TYPE_GPU|CL_DEVICE_TYPE_ACCELERATOR)) {
 
63
                case CL_DEVICE_TYPE_CPU:
 
64
                    printf(" CPU");
 
65
                break;
 
66
                case CL_DEVICE_TYPE_GPU:
 
67
                    printf(" GPU");
 
68
                break;
 
69
                case CL_DEVICE_TYPE_ACCELERATOR:
 
70
                    printf(" ACCELERATOR");
 
71
                break;
 
72
            }
 
73
 
 
74
            if ((*param)&CL_DEVICE_TYPE_DEFAULT) printf(" (*)");
 
75
 
 
76
            err = clGetDeviceInfo(devices[j], CL_DEVICE_NAME, sizeof(param), param, NULL);
 
77
            if (err != CL_SUCCESS) {
 
78
                puts(" Unknown device");
 
79
                continue;
 
80
            } else {
 
81
                printf(" %s", param);
 
82
            }
 
83
            
 
84
            err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_CLOCK_FREQUENCY, sizeof(param), param, NULL);
 
85
            if (err == CL_SUCCESS) {
 
86
                printf(", %u MHZ", *(cl_uint*)param);
 
87
            }
 
88
 
 
89
            err = clGetDeviceInfo(devices[j], CL_DEVICE_ERROR_CORRECTION_SUPPORT, sizeof(param), param, NULL);
 
90
            if ((err == CL_SUCCESS)&&(*(cl_bool*)param)) {
 
91
                printf(", ECC");
 
92
            }
 
93
            
 
94
            printf("\n");
 
95
 
 
96
            err = clGetDeviceInfo(devices[j], CL_DEVICE_GLOBAL_MEM_SIZE, sizeof(param), param, NULL);
 
97
            if (err == CL_SUCCESS) {
 
98
                printf("  Global Memory: %u MB\n", (*(cl_ulong*)param)/1024/1024);
 
99
            }
 
100
 
 
101
            err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_MEM_ALLOC_SIZE, sizeof(param), param, NULL);
 
102
            if (err == CL_SUCCESS) {
 
103
                printf("  Maximum Allocation: %u MB\n", (*(cl_ulong*)param)/1024/1024);
 
104
            }
 
105
 
 
106
            err = clGetDeviceInfo(devices[j], CL_DEVICE_MIN_DATA_TYPE_ALIGN_SIZE, sizeof(param), param, NULL);
 
107
            if (err == CL_SUCCESS) {
 
108
                printf("  Sufficient Alignment: %u\n", (*(cl_uint*)param));
 
109
            }
 
110
 
 
111
            err = clGetDeviceInfo(devices[j], CL_DEVICE_LOCAL_MEM_TYPE, sizeof(param), param, NULL);
 
112
            if ((err == CL_SUCCESS)&&(*(cl_device_local_mem_type*)param == CL_LOCAL)) {
 
113
                printf("  Local Memory");
 
114
                err = clGetDeviceInfo(devices[j], CL_DEVICE_LOCAL_MEM_SIZE, sizeof(param), param, NULL);
 
115
                if (err == CL_SUCCESS) {
 
116
                    printf(": %u KB", (*(cl_ulong*)param)/1024);
 
117
                }
 
118
                printf("\n");
 
119
            }
 
120
 
 
121
            printf("  Constant Memory: ");
 
122
            err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE, sizeof(param), param, NULL);
 
123
            if (err == CL_SUCCESS) {
 
124
                printf("%u KB", *(((cl_ulong*)param))/1024);
 
125
            }
 
126
            err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_CONSTANT_ARGS, sizeof(param), param, NULL);
 
127
            if (err == CL_SUCCESS) {
 
128
                printf(" %u parameters max", *(((cl_uint*)param)));
 
129
                
 
130
            }
 
131
            printf("\n");
 
132
 
 
133
            err = clGetDeviceInfo(devices[j], CL_DEVICE_ENDIAN_LITTLE, sizeof(param), param, NULL);
 
134
            if (err == CL_SUCCESS) {
 
135
                printf("  Endianess: %s\n", (*(cl_bool*)param)?"Little":"Big");
 
136
            }
 
137
            
 
138
            err = clGetDeviceInfo(devices[j], CL_DRIVER_VERSION, sizeof(param), param, NULL);
 
139
            if (err == CL_SUCCESS) {
 
140
                printf("  Driver Version: %s\n", param);
 
141
            }
 
142
            
 
143
            err = clGetDeviceInfo(devices[j], CL_DEVICE_VERSION, sizeof(param), param, NULL);
 
144
            if (err == CL_SUCCESS) {
 
145
                printf("  OpenCL Version: %s\n", param);
 
146
            }
 
147
 
 
148
            err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_COMPUTE_UNITS, sizeof(param), param, NULL);
 
149
            if (err == CL_SUCCESS) {
 
150
                printf("  Compute Units: %u\n", *(cl_uint*)param);
 
151
            }
 
152
 
 
153
            err = clGetDeviceInfo(devices[j], CL_DEVICE_ADDRESS_BITS, sizeof(param), param, NULL);
 
154
            if (err == CL_SUCCESS) {
 
155
                printf("  Maximum Work-items: 2^%u (global, in one dimmension)\n", *(cl_uint*)param);
 
156
            }
 
157
            
 
158
            err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_WORK_GROUP_SIZE, sizeof(param), param, NULL);
 
159
            if (err == CL_SUCCESS) {
 
160
                printf("  Group Size: %u\n", *(size_t*)param);
 
161
            }
 
162
 
 
163
            err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS, sizeof(param), param, NULL);
 
164
            if (err == CL_SUCCESS) {
 
165
                dim = *(cl_uint*)param;
 
166
                
 
167
                err = clGetDeviceInfo(devices[j], CL_DEVICE_MAX_WORK_ITEM_SIZES, sizeof(param), param, NULL);
 
168
                if (err == CL_SUCCESS) {
 
169
                    printf("  Dimensions: ");
 
170
                    for (k = 0; k < dim; k++) {
 
171
                        if (k) printf(", ");
 
172
                        printf("%u", *(((size_t*)param)+k));
 
173
                    }
 
174
                    printf("\n");
 
175
                }
 
176
            }
 
177
 
 
178
            err = clGetDeviceInfo(devices[j], CL_DEVICE_EXTENSIONS, sizeof(param), param, NULL);
 
179
            if (err == CL_SUCCESS) {
 
180
                printf("  Double Support: ");
 
181
                if (strstr(param, "cl_khr_fp64"))
 
182
                    printf("Yes");
 
183
                else
 
184
                    printf("No");
 
185
                printf("\n");
 
186
                
 
187
//              printf("  Extensions: %s\n", param);
 
188
            } else {
 
189
 
 
190
                printf("  Double Support: No\n");
 
191
            }
 
192
            
 
193
            
 
194
            
 
195
        }
 
196
    }
 
197
 
 
198
    return 0;
 
199
}