#253

Committed 08 Apr 2025 09:51AM UTC coverage: 64.326%. Remained the same

Build # #253

Build Type

push

Committed by

Commit Message

Change maven prerequisites

Run Details

1145 of 1780 relevant lines covered (64.33%)

0.64 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

3.33

/src/main/java/net/ladenthin/bitcoinaddressfinder/opencl/OpenCLDevice.java

// @formatter:off
/**
 * Copyright 2022 Bernard Ladenthin bernard.ladenthin@gmail.com
 *
 * 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.
 *
 */
// @formatter:on
package net.ladenthin.bitcoinaddressfinder.opencl;

import com.google.errorprone.annotations.Immutable;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import java.io.Serializable;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import lombok.EqualsAndHashCode;
import lombok.ToString;
import org.apache.maven.artifact.versioning.ComparableVersion;
import org.jocl.CL;
import org.jocl.cl_device_id;
import org.jspecify.annotations.NonNull;

@Immutable
@ToString
@EqualsAndHashCode
public class OpenCLDevice implements Serializable {
    
    @NonNull
    private final transient cl_device_id id;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_NAME}.
     */
    private final String deviceName;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_VENDOR}.
     */
    private final String deviceVendor;
    
    /**
     * See {@link org.jocl.CL#CL_DRIVER_VERSION}.
     */
    private final String driverVersion;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_PROFILE}.
     */
    private final String deviceProfile;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_VERSION}.
     */
    private final String deviceVersion;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_EXTENSIONS}.
     */
    private final String deviceExtensions;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_TYPE}.
     */
    private final long deviceType;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_MAX_COMPUTE_UNITS}.
     */
    private final int maxComputeUnits;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS}.
     */
    private final long maxWorkItemDimensions;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_MAX_WORK_ITEM_SIZES}.
     */
    private final long maxWorkItemSizes[];
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_MAX_WORK_GROUP_SIZE}.
     */
    private final long maxWorkGroupSize;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_MAX_CLOCK_FREQUENCY}.
     */
    private final long maxClockFrequency;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_ADDRESS_BITS}.
     */
    private final int addressBits;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_MAX_MEM_ALLOC_SIZE}.
     */
    private final long maxMemAllocSize;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_GLOBAL_MEM_SIZE}.
     */
    private final long globalMemSize;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_ERROR_CORRECTION_SUPPORT}.
     */
    private final long errorCorrectionSupport;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_LOCAL_MEM_TYPE}.
     */
    private final int localMemType;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_LOCAL_MEM_SIZE}.
     */
    private final long localMemSize;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE}.
     */
    private final long maxConstantBufferSize;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_QUEUE_PROPERTIES}.
     */
    private final long queueProperties;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_IMAGE_SUPPORT}.
     */
    private final int imageSupport;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_MAX_READ_IMAGE_ARGS}.
     */
    private final int maxReadImageArgs;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_MAX_WRITE_IMAGE_ARGS}.
     */
    private final int maxWriteImageArgs;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_SINGLE_FP_CONFIG}.
     */
    private final long singleFpConfig;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_IMAGE2D_MAX_WIDTH}.
     */
    private final long image2dMaxWidth;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_IMAGE2D_MAX_HEIGHT}.
     */
    private final long image2dMaxHeight;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_IMAGE3D_MAX_WIDTH}.
     */
    private final long image3dMaxWidth;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_IMAGE3D_MAX_HEIGHT}.
     */
    private final long image3dMaxHeight;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_IMAGE3D_MAX_DEPTH}.
     */
    private final long image3dMaxDepth;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR}.
     */
    private final int preferredVectorWidthChar;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT}.
     */
    private final int preferredVectorWidthShort;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT}.
     */
    private final int preferredVectorWidthInt;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG}.
     */
    private final int preferredVectorWidthLong;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT}.
     */
    private final int preferredVectorWidthFloat;
    
    /**
     * See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE}.
     */
    private final int preferredVectorWidthDouble;
    
    public OpenCLDevice(
            cl_device_id id,
            String deviceName,
            String deviceVendor,
            String driverVersion,
            String deviceProfile,
            String deviceVersion,
            String deviceExtensions,
            long deviceType,
            int maxComputeUnits,
            long maxWorkItemDimensions,
            long maxWorkItemSizes[],
            long maxWorkGroupSize,
            long maxClockFrequency,
            int addressBits,
            long maxMemAllocSize,
            long globalMemSize,
            long errorCorrectionSupport,
            int localMemType,
            long localMemSize,
            long maxConstantBufferSize,
            long queueProperties,
            int imageSupport,
            int maxReadImageArgs,
            int maxWriteImageArgs,
            long singleFpConfig,
            long image2dMaxWidth,
            long image2dMaxHeight,
            long image3dMaxWidth,
            long image3dMaxHeight,
            long image3dMaxDepth,
            int preferredVectorWidthChar,
            int preferredVectorWidthShort,
            int preferredVectorWidthInt,
            int preferredVectorWidthLong,
            int preferredVectorWidthFloat,
            int preferredVectorWidthDouble
    ) {
        this.id = id;
        this.deviceName = deviceName;
        this.deviceVendor = deviceVendor;
        this.driverVersion = driverVersion;
        this.deviceProfile = deviceProfile;
        this.deviceVersion = deviceVersion;
        this.deviceExtensions = deviceExtensions;
        this.deviceType = deviceType;
        this.maxComputeUnits = maxComputeUnits;
        this.maxWorkItemDimensions = maxWorkItemDimensions;
        this.maxWorkItemSizes = maxWorkItemSizes;
        this.maxWorkGroupSize = maxWorkGroupSize;
        this.maxClockFrequency = maxClockFrequency;
        this.addressBits = addressBits;
        this.maxMemAllocSize = maxMemAllocSize;
        this.globalMemSize = globalMemSize;
        this.errorCorrectionSupport = errorCorrectionSupport;
        this.localMemType = localMemType;
        this.localMemSize = localMemSize;
        this.maxConstantBufferSize = maxConstantBufferSize;
        this.queueProperties = queueProperties;
        this.imageSupport = imageSupport;
        this.maxReadImageArgs = maxReadImageArgs;
        this.maxWriteImageArgs = maxWriteImageArgs;
        this.singleFpConfig = singleFpConfig;
        this.image2dMaxWidth = image2dMaxWidth;
        this.image2dMaxHeight = image2dMaxHeight;
        this.image3dMaxWidth = image3dMaxWidth;
        this.image3dMaxHeight = image3dMaxHeight;
        this.image3dMaxDepth = image3dMaxDepth;
        this.preferredVectorWidthChar = preferredVectorWidthChar;
        this.preferredVectorWidthShort = preferredVectorWidthShort;
        this.preferredVectorWidthInt = preferredVectorWidthInt;
        this.preferredVectorWidthLong = preferredVectorWidthLong;
        this.preferredVectorWidthFloat = preferredVectorWidthFloat;
        this.preferredVectorWidthDouble = preferredVectorWidthDouble;
    }

    public cl_device_id getId() {
        return id;
    }

    public String getDeviceName() {
        return deviceName;
    }

    public String getDeviceVendor() {
        return deviceVendor;
    }

    public String getDriverVersion() {
        return driverVersion;
    }

    public String getDeviceProfile() {
        return deviceProfile;
    }

    public String getDeviceVersion() {
        return deviceVersion;
    }

    public String getDeviceExtensions() {
        return deviceExtensions;
    }

    public long getDeviceType() {
        return deviceType;
    }

    public int getMaxComputeUnits() {
        return maxComputeUnits;
    }

    public long getMaxWorkItemDimensions() {
        return maxWorkItemDimensions;
    }

    public long[] getMaxWorkItemSizes() {
        return maxWorkItemSizes;
    }

    public long getMaxWorkGroupSize() {
        return maxWorkGroupSize;
    }

    public long getMaxClockFrequency() {
        return maxClockFrequency;
    }

    public int getAddressBits() {
        return addressBits;
    }

    public long getMaxMemAllocSize() {
        return maxMemAllocSize;
    }

    public long getGlobalMemSize() {
        return globalMemSize;
    }

    public long getErrorCorrectionSupport() {
        return errorCorrectionSupport;
    }

    public int getLocalMemType() {
        return localMemType;
    }

    public long getLocalMemSize() {
        return localMemSize;
    }

    public long getMaxConstantBufferSize() {
        return maxConstantBufferSize;
    }

    public long getQueueProperties() {
        return queueProperties;
    }

    public int getImageSupport() {
        return imageSupport;
    }

    public int getMaxReadImageArgs() {
        return maxReadImageArgs;
    }

    public int getMaxWriteImageArgs() {
        return maxWriteImageArgs;
    }

    public long getSingleFpConfig() {
        return singleFpConfig;
    }

    public long getImage2dMaxWidth() {
        return image2dMaxWidth;
    }

    public long getImage2dMaxHeight() {
        return image2dMaxHeight;
    }

    public long getImage3dMaxWidth() {
        return image3dMaxWidth;
    }

    public long getImage3dMaxHeight() {
        return image3dMaxHeight;
    }

    public long getImage3dMaxDepth() {
        return image3dMaxDepth;
    }

    public int getPreferredVectorWidthChar() {
        return preferredVectorWidthChar;
    }

    public int getPreferredVectorWidthShort() {
        return preferredVectorWidthShort;
    }

    public int getPreferredVectorWidthInt() {
        return preferredVectorWidthInt;
    }

    public int getPreferredVectorWidthLong() {
        return preferredVectorWidthLong;
    }

    public int getPreferredVectorWidthFloat() {
        return preferredVectorWidthFloat;
    }

    public int getPreferredVectorWidthDouble() {
        return preferredVectorWidthDouble;
    }
    
    public String toStringPretty() {
        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
        final Charset charset = java.nio.charset.StandardCharsets.UTF_8;
        
        try (PrintStream ps = new PrintStream(baos, true, charset)) {
            ps.println("--- Info for device "+deviceName+": ---");
            ps.printf("CL_DEVICE_NAME: \t\t\t%s\n", deviceName);
            ps.printf("CL_DEVICE_VENDOR: \t\t\t%s\n", deviceVendor);
            ps.printf("CL_DRIVER_VERSION: \t\t\t%s\n", driverVersion);
            ps.printf("CL_DEVICE_PROFILE: \t\t\t%s\n", deviceProfile);
            ps.printf("CL_DEVICE_VERSION: \t\t\t%s\n", deviceVersion);
            ps.printf("CL_DEVICE_EXTENSIONS: \t\t\t%s\n", deviceExtensions);
            ps.printf("CL_DEVICE_TYPE:\t\t\t\t%s\n", CL.stringFor_cl_device_type(deviceType));
            ps.printf("CL_DEVICE_MAX_COMPUTE_UNITS:\t\t%d\n", maxComputeUnits);
            ps.printf("CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS:\t%d\n", maxWorkItemDimensions);
            ps.printf("CL_DEVICE_MAX_WORK_ITEM_SIZES:\t\t%d / %d / %d \n",
                maxWorkItemSizes[0], maxWorkItemSizes[1], maxWorkItemSizes[2]);
            ps.printf("CL_DEVICE_MAX_WORK_GROUP_SIZE:\t\t%d\n", maxWorkGroupSize);
            ps.printf("CL_DEVICE_MAX_CLOCK_FREQUENCY:\t\t%d MHz\n", maxClockFrequency);
            ps.printf("CL_DEVICE_ADDRESS_BITS:\t\t\t%d\n", addressBits);
            ps.printf("CL_DEVICE_MAX_MEM_ALLOC_SIZE:\t\t%d MByte\n", (int)(maxMemAllocSize / (1024 * 1024)));
            ps.printf("CL_DEVICE_GLOBAL_MEM_SIZE:\t\t%d MByte\n", (int)(globalMemSize / (1024 * 1024)));
            ps.printf("CL_DEVICE_ERROR_CORRECTION_SUPPORT:\t%s\n", errorCorrectionSupport != 0 ? "yes" : "no");
            ps.printf("CL_DEVICE_LOCAL_MEM_TYPE:\t\t%s\n", CL.stringFor_cl_device_local_mem_type(localMemType));
            ps.printf("CL_DEVICE_LOCAL_MEM_SIZE:\t\t%d KByte\n", (int)(localMemSize / 1024));
            ps.printf("CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE:\t%d KByte\n", (int)(maxConstantBufferSize / 1024));
            ps.printf("CL_DEVICE_QUEUE_PROPERTIES:\t\t%s\n", CL.stringFor_cl_command_queue_properties(queueProperties));
            ps.printf("CL_DEVICE_IMAGE_SUPPORT:\t\t%d\n", imageSupport);
            ps.printf("CL_DEVICE_MAX_READ_IMAGE_ARGS:\t\t%d\n", maxReadImageArgs);
            ps.printf("CL_DEVICE_MAX_WRITE_IMAGE_ARGS:\t\t%d\n", maxWriteImageArgs);
            ps.printf("CL_DEVICE_SINGLE_FP_CONFIG:\t\t%s\n", CL.stringFor_cl_device_fp_config(singleFpConfig));
            ps.printf("CL_DEVICE_2D_MAX_WIDTH\t\t\t%d\n", image2dMaxWidth);
            ps.printf("CL_DEVICE_2D_MAX_HEIGHT\t\t\t%d\n", image2dMaxHeight);
            ps.printf("CL_DEVICE_3D_MAX_WIDTH\t\t\t%d\n", image3dMaxWidth);
            ps.printf("CL_DEVICE_3D_MAX_HEIGHT\t\t\t%d\n", image3dMaxHeight);
            ps.printf("CL_DEVICE_3D_MAX_DEPTH\t\t\t%d\n", image3dMaxDepth);
            ps.printf("CL_DEVICE_PREFERRED_VECTOR_WIDTH_<t>\t");
            ps.printf("CHAR %d, SHORT %d, INT %d, LONG %d, FLOAT %d, DOUBLE %d\n\n\n",
               preferredVectorWidthChar, preferredVectorWidthShort,
               preferredVectorWidthInt, preferredVectorWidthLong,
               preferredVectorWidthFloat, preferredVectorWidthDouble);
        }
        
        String string = new String(baos.toByteArray(), charset);
        return string;
    }
    
    public ComparableVersion getDeviceVersionAsComparableVersion() {
        return getComparableVersionFromDeviceVersion(getDeviceVersion());
    }
    
    public static ComparableVersion getComparableVersionFromDeviceVersion(String deviceVersion) {
        String s = deviceVersion;
        s = s.replace("OpenCL ", "");
        s = s.replace("CUDA", "");
        return new ComparableVersion(s);
    }
}

1	// @formatter:off
2	/**
3	* Copyright 2022 Bernard Ladenthin bernard.ladenthin@gmail.com
4	*
5	* Licensed under the Apache License, Version 2.0 (the "License");
6	* you may not use this file except in compliance with the License.
7	* You may obtain a copy of the License at
8	*
9	* http://www.apache.org/licenses/LICENSE-2.0
10	*
11	* Unless required by applicable law or agreed to in writing, software
12	* distributed under the License is distributed on an "AS IS" BASIS,
13	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14	* See the License for the specific language governing permissions and
15	* limitations under the License.
16	*
17	*/
18	// @formatter:on
19	package net.ladenthin.bitcoinaddressfinder.opencl;
20
21	import com.google.errorprone.annotations.Immutable;
22	import java.io.ByteArrayOutputStream;
23	import java.io.PrintStream;
24	import java.io.Serializable;
25	import java.nio.charset.Charset;
26	import java.util.ArrayList;
27	import java.util.Arrays;
28	import java.util.List;
29	import lombok.EqualsAndHashCode;
30	import lombok.ToString;
31	import org.apache.maven.artifact.versioning.ComparableVersion;
32	import org.jocl.CL;
33	import org.jocl.cl_device_id;
34	import org.jspecify.annotations.NonNull;
35
36	@Immutable
37	@ToString
38	@EqualsAndHashCode
39	public class OpenCLDevice implements Serializable {
40
41	@NonNull
42	private final transient cl_device_id id;
43
44	/**
45	* See {@link org.jocl.CL#CL_DEVICE_NAME}.
46	*/
47	private final String deviceName;
48
49	/**
50	* See {@link org.jocl.CL#CL_DEVICE_VENDOR}.
51	*/
52	private final String deviceVendor;
53
54	/**
55	* See {@link org.jocl.CL#CL_DRIVER_VERSION}.
56	*/
57	private final String driverVersion;
58
59	/**
60	* See {@link org.jocl.CL#CL_DEVICE_PROFILE}.
61	*/
62	private final String deviceProfile;
63
64	/**
65	* See {@link org.jocl.CL#CL_DEVICE_VERSION}.
66	*/
67	private final String deviceVersion;
68
69	/**
70	* See {@link org.jocl.CL#CL_DEVICE_EXTENSIONS}.
71	*/
72	private final String deviceExtensions;
73
74	/**
75	* See {@link org.jocl.CL#CL_DEVICE_TYPE}.
76	*/
77	private final long deviceType;
78
79	/**
80	* See {@link org.jocl.CL#CL_DEVICE_MAX_COMPUTE_UNITS}.
81	*/
82	private final int maxComputeUnits;
83
84	/**
85	* See {@link org.jocl.CL#CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS}.
86	*/
87	private final long maxWorkItemDimensions;
88
89	/**
90	* See {@link org.jocl.CL#CL_DEVICE_MAX_WORK_ITEM_SIZES}.
91	*/
92	private final long maxWorkItemSizes[];
93
94	/**
95	* See {@link org.jocl.CL#CL_DEVICE_MAX_WORK_GROUP_SIZE}.
96	*/
97	private final long maxWorkGroupSize;
98
99	/**
100	* See {@link org.jocl.CL#CL_DEVICE_MAX_CLOCK_FREQUENCY}.
101	*/
102	private final long maxClockFrequency;
103
104	/**
105	* See {@link org.jocl.CL#CL_DEVICE_ADDRESS_BITS}.
106	*/
107	private final int addressBits;
108
109	/**
110	* See {@link org.jocl.CL#CL_DEVICE_MAX_MEM_ALLOC_SIZE}.
111	*/
112	private final long maxMemAllocSize;
113
114	/**
115	* See {@link org.jocl.CL#CL_DEVICE_GLOBAL_MEM_SIZE}.
116	*/
117	private final long globalMemSize;
118
119	/**
120	* See {@link org.jocl.CL#CL_DEVICE_ERROR_CORRECTION_SUPPORT}.
121	*/
122	private final long errorCorrectionSupport;
123
124	/**
125	* See {@link org.jocl.CL#CL_DEVICE_LOCAL_MEM_TYPE}.
126	*/
127	private final int localMemType;
128
129	/**
130	* See {@link org.jocl.CL#CL_DEVICE_LOCAL_MEM_SIZE}.
131	*/
132	private final long localMemSize;
133
134	/**
135	* See {@link org.jocl.CL#CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE}.
136	*/
137	private final long maxConstantBufferSize;
138
139	/**
140	* See {@link org.jocl.CL#CL_DEVICE_QUEUE_PROPERTIES}.
141	*/
142	private final long queueProperties;
143
144	/**
145	* See {@link org.jocl.CL#CL_DEVICE_IMAGE_SUPPORT}.
146	*/
147	private final int imageSupport;
148
149	/**
150	* See {@link org.jocl.CL#CL_DEVICE_MAX_READ_IMAGE_ARGS}.
151	*/
152	private final int maxReadImageArgs;
153
154	/**
155	* See {@link org.jocl.CL#CL_DEVICE_MAX_WRITE_IMAGE_ARGS}.
156	*/
157	private final int maxWriteImageArgs;
158
159	/**
160	* See {@link org.jocl.CL#CL_DEVICE_SINGLE_FP_CONFIG}.
161	*/
162	private final long singleFpConfig;
163
164	/**
165	* See {@link org.jocl.CL#CL_DEVICE_IMAGE2D_MAX_WIDTH}.
166	*/
167	private final long image2dMaxWidth;
168
169	/**
170	* See {@link org.jocl.CL#CL_DEVICE_IMAGE2D_MAX_HEIGHT}.
171	*/
172	private final long image2dMaxHeight;
173
174	/**
175	* See {@link org.jocl.CL#CL_DEVICE_IMAGE3D_MAX_WIDTH}.
176	*/
177	private final long image3dMaxWidth;
178
179	/**
180	* See {@link org.jocl.CL#CL_DEVICE_IMAGE3D_MAX_HEIGHT}.
181	*/
182	private final long image3dMaxHeight;
183
184	/**
185	* See {@link org.jocl.CL#CL_DEVICE_IMAGE3D_MAX_DEPTH}.
186	*/
187	private final long image3dMaxDepth;
188
189	/**
190	* See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_CHAR}.
191	*/
192	private final int preferredVectorWidthChar;
193
194	/**
195	* See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_SHORT}.
196	*/
197	private final int preferredVectorWidthShort;
198
199	/**
200	* See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_INT}.
201	*/
202	private final int preferredVectorWidthInt;
203
204	/**
205	* See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_LONG}.
206	*/
207	private final int preferredVectorWidthLong;
208
209	/**
210	* See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT}.
211	*/
212	private final int preferredVectorWidthFloat;
213
214	/**
215	* See {@link org.jocl.CL#CL_DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE}.
216	*/
217	private final int preferredVectorWidthDouble;
218
219	public OpenCLDevice(
220	cl_device_id id,
221	String deviceName,
222	String deviceVendor,
223	String driverVersion,
224	String deviceProfile,
225	String deviceVersion,
226	String deviceExtensions,
227	long deviceType,
228	int maxComputeUnits,
229	long maxWorkItemDimensions,
230	long maxWorkItemSizes[],
231	long maxWorkGroupSize,
232	long maxClockFrequency,
233	int addressBits,
234	long maxMemAllocSize,
235	long globalMemSize,
236	long errorCorrectionSupport,
237	int localMemType,
238	long localMemSize,
239	long maxConstantBufferSize,
240	long queueProperties,
241	int imageSupport,
242	int maxReadImageArgs,
243	int maxWriteImageArgs,
244	long singleFpConfig,
245	long image2dMaxWidth,
246	long image2dMaxHeight,
247	long image3dMaxWidth,
248	long image3dMaxHeight,
249	long image3dMaxDepth,
250	int preferredVectorWidthChar,
251	int preferredVectorWidthShort,
252	int preferredVectorWidthInt,
253	int preferredVectorWidthLong,
254	int preferredVectorWidthFloat,
255	int preferredVectorWidthDouble
256	) {	×
257	this.id = id;	×
258	this.deviceName = deviceName;	×
259	this.deviceVendor = deviceVendor;	×
260	this.driverVersion = driverVersion;	×
261	this.deviceProfile = deviceProfile;	×
262	this.deviceVersion = deviceVersion;	×
263	this.deviceExtensions = deviceExtensions;	×
264	this.deviceType = deviceType;	×
265	this.maxComputeUnits = maxComputeUnits;	×
266	this.maxWorkItemDimensions = maxWorkItemDimensions;	×
267	this.maxWorkItemSizes = maxWorkItemSizes;	×
268	this.maxWorkGroupSize = maxWorkGroupSize;	×
269	this.maxClockFrequency = maxClockFrequency;	×
270	this.addressBits = addressBits;	×
271	this.maxMemAllocSize = maxMemAllocSize;	×
272	this.globalMemSize = globalMemSize;	×
273	this.errorCorrectionSupport = errorCorrectionSupport;	×
274	this.localMemType = localMemType;	×
275	this.localMemSize = localMemSize;	×
276	this.maxConstantBufferSize = maxConstantBufferSize;	×
277	this.queueProperties = queueProperties;	×
278	this.imageSupport = imageSupport;	×
279	this.maxReadImageArgs = maxReadImageArgs;	×
280	this.maxWriteImageArgs = maxWriteImageArgs;	×
281	this.singleFpConfig = singleFpConfig;	×
282	this.image2dMaxWidth = image2dMaxWidth;	×
283	this.image2dMaxHeight = image2dMaxHeight;	×
284	this.image3dMaxWidth = image3dMaxWidth;	×
285	this.image3dMaxHeight = image3dMaxHeight;	×
286	this.image3dMaxDepth = image3dMaxDepth;	×
287	this.preferredVectorWidthChar = preferredVectorWidthChar;	×
288	this.preferredVectorWidthShort = preferredVectorWidthShort;	×
289	this.preferredVectorWidthInt = preferredVectorWidthInt;	×
290	this.preferredVectorWidthLong = preferredVectorWidthLong;	×
291	this.preferredVectorWidthFloat = preferredVectorWidthFloat;	×
292	this.preferredVectorWidthDouble = preferredVectorWidthDouble;	×
293	}	×
294
295	public cl_device_id getId() {
296	return id;	×
297	}
298
299	public String getDeviceName() {
300	return deviceName;	×
301	}
302
303	public String getDeviceVendor() {
304	return deviceVendor;	×
305	}
306
307	public String getDriverVersion() {
308	return driverVersion;	×
309	}
310
311	public String getDeviceProfile() {
312	return deviceProfile;	×
313	}
314
315	public String getDeviceVersion() {
316	return deviceVersion;	×
317	}
318
319	public String getDeviceExtensions() {
320	return deviceExtensions;	×
321	}
322
323	public long getDeviceType() {
324	return deviceType;	×
325	}
326
327	public int getMaxComputeUnits() {
328	return maxComputeUnits;	×
329	}
330
331	public long getMaxWorkItemDimensions() {
332	return maxWorkItemDimensions;	×
333	}
334
335	public long[] getMaxWorkItemSizes() {
336	return maxWorkItemSizes;	×
337	}
338
339	public long getMaxWorkGroupSize() {
340	return maxWorkGroupSize;	×
341	}
342
343	public long getMaxClockFrequency() {
344	return maxClockFrequency;	×
345	}
346
347	public int getAddressBits() {
348	return addressBits;	×
349	}
350
351	public long getMaxMemAllocSize() {
352	return maxMemAllocSize;	×
353	}
354
355	public long getGlobalMemSize() {
356	return globalMemSize;	×
357	}
358
359	public long getErrorCorrectionSupport() {
360	return errorCorrectionSupport;	×
361	}
362
363	public int getLocalMemType() {
364	return localMemType;	×
365	}
366
367	public long getLocalMemSize() {
368	return localMemSize;	×
369	}
370
371	public long getMaxConstantBufferSize() {
372	return maxConstantBufferSize;	×
373	}
374
375	public long getQueueProperties() {
376	return queueProperties;	×
377	}
378
379	public int getImageSupport() {
380	return imageSupport;	×
381	}
382
383	public int getMaxReadImageArgs() {
384	return maxReadImageArgs;	×
385	}
386
387	public int getMaxWriteImageArgs() {
388	return maxWriteImageArgs;	×
389	}
390
391	public long getSingleFpConfig() {
392	return singleFpConfig;	×
393	}
394
395	public long getImage2dMaxWidth() {
396	return image2dMaxWidth;	×
397	}
398
399	public long getImage2dMaxHeight() {
400	return image2dMaxHeight;	×
401	}
402
403	public long getImage3dMaxWidth() {
404	return image3dMaxWidth;	×
405	}
406
407	public long getImage3dMaxHeight() {
408	return image3dMaxHeight;	×
409	}
410
411	public long getImage3dMaxDepth() {
412	return image3dMaxDepth;	×
413	}
414
415	public int getPreferredVectorWidthChar() {
416	return preferredVectorWidthChar;	×
417	}
418
419	public int getPreferredVectorWidthShort() {
420	return preferredVectorWidthShort;	×
421	}
422
423	public int getPreferredVectorWidthInt() {
424	return preferredVectorWidthInt;	×
425	}
426
427	public int getPreferredVectorWidthLong() {
428	return preferredVectorWidthLong;	×
429	}
430
431	public int getPreferredVectorWidthFloat() {
432	return preferredVectorWidthFloat;	×
433	}
434
435	public int getPreferredVectorWidthDouble() {
436	return preferredVectorWidthDouble;	×
437	}
438
439	public String toStringPretty() {
440	final ByteArrayOutputStream baos = new ByteArrayOutputStream();	×
441	final Charset charset = java.nio.charset.StandardCharsets.UTF_8;	×
442
443	try (PrintStream ps = new PrintStream(baos, true, charset)) {	×
444	ps.println("--- Info for device "+deviceName+": ---");	×
445	ps.printf("CL_DEVICE_NAME: \t\t\t%s\n", deviceName);	×
446	ps.printf("CL_DEVICE_VENDOR: \t\t\t%s\n", deviceVendor);	×
447	ps.printf("CL_DRIVER_VERSION: \t\t\t%s\n", driverVersion);	×
448	ps.printf("CL_DEVICE_PROFILE: \t\t\t%s\n", deviceProfile);	×
449	ps.printf("CL_DEVICE_VERSION: \t\t\t%s\n", deviceVersion);	×
450	ps.printf("CL_DEVICE_EXTENSIONS: \t\t\t%s\n", deviceExtensions);	×
451	ps.printf("CL_DEVICE_TYPE:\t\t\t\t%s\n", CL.stringFor_cl_device_type(deviceType));	×
452	ps.printf("CL_DEVICE_MAX_COMPUTE_UNITS:\t\t%d\n", maxComputeUnits);	×
453	ps.printf("CL_DEVICE_MAX_WORK_ITEM_DIMENSIONS:\t%d\n", maxWorkItemDimensions);	×
454	ps.printf("CL_DEVICE_MAX_WORK_ITEM_SIZES:\t\t%d / %d / %d \n",	×
455	maxWorkItemSizes[0], maxWorkItemSizes[1], maxWorkItemSizes[2]);	×
456	ps.printf("CL_DEVICE_MAX_WORK_GROUP_SIZE:\t\t%d\n", maxWorkGroupSize);	×
457	ps.printf("CL_DEVICE_MAX_CLOCK_FREQUENCY:\t\t%d MHz\n", maxClockFrequency);	×
458	ps.printf("CL_DEVICE_ADDRESS_BITS:\t\t\t%d\n", addressBits);	×
459	ps.printf("CL_DEVICE_MAX_MEM_ALLOC_SIZE:\t\t%d MByte\n", (int)(maxMemAllocSize / (1024 * 1024)));	×
460	ps.printf("CL_DEVICE_GLOBAL_MEM_SIZE:\t\t%d MByte\n", (int)(globalMemSize / (1024 * 1024)));	×
461	ps.printf("CL_DEVICE_ERROR_CORRECTION_SUPPORT:\t%s\n", errorCorrectionSupport != 0 ? "yes" : "no");	×
462	ps.printf("CL_DEVICE_LOCAL_MEM_TYPE:\t\t%s\n", CL.stringFor_cl_device_local_mem_type(localMemType));	×
463	ps.printf("CL_DEVICE_LOCAL_MEM_SIZE:\t\t%d KByte\n", (int)(localMemSize / 1024));	×
464	ps.printf("CL_DEVICE_MAX_CONSTANT_BUFFER_SIZE:\t%d KByte\n", (int)(maxConstantBufferSize / 1024));	×
465	ps.printf("CL_DEVICE_QUEUE_PROPERTIES:\t\t%s\n", CL.stringFor_cl_command_queue_properties(queueProperties));	×
466	ps.printf("CL_DEVICE_IMAGE_SUPPORT:\t\t%d\n", imageSupport);	×
467	ps.printf("CL_DEVICE_MAX_READ_IMAGE_ARGS:\t\t%d\n", maxReadImageArgs);	×
468	ps.printf("CL_DEVICE_MAX_WRITE_IMAGE_ARGS:\t\t%d\n", maxWriteImageArgs);	×
469	ps.printf("CL_DEVICE_SINGLE_FP_CONFIG:\t\t%s\n", CL.stringFor_cl_device_fp_config(singleFpConfig));	×
470	ps.printf("CL_DEVICE_2D_MAX_WIDTH\t\t\t%d\n", image2dMaxWidth);	×
471	ps.printf("CL_DEVICE_2D_MAX_HEIGHT\t\t\t%d\n", image2dMaxHeight);	×
472	ps.printf("CL_DEVICE_3D_MAX_WIDTH\t\t\t%d\n", image3dMaxWidth);	×
473	ps.printf("CL_DEVICE_3D_MAX_HEIGHT\t\t\t%d\n", image3dMaxHeight);	×
474	ps.printf("CL_DEVICE_3D_MAX_DEPTH\t\t\t%d\n", image3dMaxDepth);	×
475	ps.printf("CL_DEVICE_PREFERRED_VECTOR_WIDTH_<t>\t");	×
476	ps.printf("CHAR %d, SHORT %d, INT %d, LONG %d, FLOAT %d, DOUBLE %d\n\n\n",	×
477	preferredVectorWidthChar, preferredVectorWidthShort,	×
478	preferredVectorWidthInt, preferredVectorWidthLong,	×
479	preferredVectorWidthFloat, preferredVectorWidthDouble);	×
480	}
481
482	String string = new String(baos.toByteArray(), charset);	×
483	return string;	×
484	}
485
486	public ComparableVersion getDeviceVersionAsComparableVersion() {
487	return getComparableVersionFromDeviceVersion(getDeviceVersion());	×
488	}
489
490	public static ComparableVersion getComparableVersionFromDeviceVersion(String deviceVersion) {
491	String s = deviceVersion;	1✔
492	s = s.replace("OpenCL ", "");	1✔
493	s = s.replace("CUDA", "");	1✔
494	return new ComparableVersion(s);	1✔
495	}
496	}

bernardladenthin / BitcoinAddressFinder / #253

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous