Rooba
/
boinc
mirror of https://github.com/BOINC/boinc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
boinc/lib/opencl_boinc.cpp

353 lines
11 KiB
C++
Raw Blame History

// This file is part of BOINC.
// http://boinc.berkeley.edu
// Copyright (C) 2013 University of California
//
// BOINC is free software; you can redistribute it and/or modify it
// under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation,
// either version 3 of the License, or (at your option) any later version.
//
// BOINC is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with BOINC. If not, see <http://www.gnu.org/licenses/>.
#if defined(_WIN32)
#include "boinc_win.h"
#else
#ifdef _USING_FCGI_
#include "boinc_fcgi.h"
#else
#include <cstdio>
#endif
#include <cstring>
#include <cstdlib>
#include <cmath>
#endif
#ifdef _WIN32
#include "win_util.h"
#endif
#include "miofile.h"
#include "parse.h"
#include "str_replace.h"
#include "util.h"
#include "opencl_boinc.h"
#ifndef _USING_FCGI_
void OPENCL_DEVICE_PROP::write_xml(MIOFILE& f, const char* tag, bool temp_file) {
f.printf(
" <%s>\n"
" <name>%s</name>\n"
" <vendor>%s</vendor>\n"
" <vendor_id>%lu</vendor_id>\n"
" <available>%d</available>\n"
" <half_fp_config>%llu</half_fp_config>\n"
" <single_fp_config>%llu</single_fp_config>\n"
" <double_fp_config>%llu</double_fp_config>\n"
" <endian_little>%d</endian_little>\n"
" <execution_capabilities>%llu</execution_capabilities>\n"
" <extensions>%s</extensions>\n"
" <global_mem_size>%llu</global_mem_size>\n"
" <local_mem_size>%llu</local_mem_size>\n"
" <max_clock_frequency>%lu</max_clock_frequency>\n"
" <max_compute_units>%lu</max_compute_units>\n"
" <nv_compute_capability_major>%lu</nv_compute_capability_major>\n"
" <nv_compute_capability_minor>%lu</nv_compute_capability_minor>\n"
" <amd_simd_per_compute_unit>%lu</amd_simd_per_compute_unit>\n"
" <amd_simd_width>%lu</amd_simd_width>\n"
" <amd_simd_instruction_width>%lu</amd_simd_instruction_width>\n"
" <opencl_platform_version>%s</opencl_platform_version>\n"
" <opencl_device_version>%s</opencl_device_version>\n"
" <opencl_driver_version>%s</opencl_driver_version>\n",
tag,
name,
vendor,
(unsigned long)vendor_id,
available ? 1 : 0,
half_fp_config,
single_fp_config,
double_fp_config,
endian_little ? 1 : 0,
execution_capabilities,
extensions,
global_mem_size,
local_mem_size,
(unsigned long)max_clock_frequency,
(unsigned long)max_compute_units,
(unsigned long)nv_compute_capability_major,
(unsigned long)nv_compute_capability_minor,
(unsigned long)amd_simd_per_compute_unit,
(unsigned long)amd_simd_width,
(unsigned long)amd_simd_instruction_width,
opencl_platform_version,
opencl_device_version,
opencl_driver_version
);
if (temp_file) {
f.printf(
" <device_num>%d</device_num>\n"
" <peak_flops>%f</peak_flops>\n"
" <opencl_available_ram>%f</opencl_available_ram>\n"
" <opencl_device_index>%d</opencl_device_index>\n"
" <warn_bad_cuda>%d</warn_bad_cuda>\n",
device_num,
peak_flops,
opencl_available_ram,
opencl_device_index,
warn_bad_cuda
);
}
f.printf(" </%s>\n", tag);
}
#endif
int OPENCL_DEVICE_PROP::parse(XML_PARSER& xp, const char* end_tag) {
int n;
unsigned long long ull;
while (!xp.get_tag()) {
if (xp.match_tag(end_tag)) {
get_device_version_int();
get_opencl_driver_revision();
return 0;
}
if (xp.parse_str("name", name, sizeof(name))) continue;
if (xp.parse_str("vendor", vendor, sizeof(vendor))) continue;
if (xp.parse_ulonglong("vendor_id", ull)) {
vendor_id = ull;
continue;
}
if (xp.parse_int("available", n)) {
available = n;
continue;
}
if (xp.parse_ulonglong("half_fp_config", ull)) {
half_fp_config = ull;
continue;
}
if (xp.parse_ulonglong("single_fp_config", ull)) {
single_fp_config = ull;
continue;
}
if (xp.parse_ulonglong("double_fp_config", ull)) {
double_fp_config = ull;
continue;
}
if (xp.parse_int("endian_little", n)) {
endian_little = n;
continue;
}
if (xp.parse_ulonglong("execution_capabilities", ull)) {
execution_capabilities = ull;
continue;
}
if (xp.parse_str("extensions",
extensions,
sizeof(extensions)
)) {
continue;
}
if (xp.parse_ulonglong("global_mem_size", ull)) {
global_mem_size = ull;
continue;
}
if (xp.parse_ulonglong("local_mem_size", ull)) {
local_mem_size = ull;
continue;
}
if (xp.parse_int("max_clock_frequency", n)) {
max_clock_frequency = n;
continue;
}
if (xp.parse_int("max_compute_units", n)) {
max_compute_units = n;
continue;
}
if (xp.parse_int("nv_compute_capability_major", n)) {
nv_compute_capability_major = n;
continue;
}
if (xp.parse_int("nv_compute_capability_minor", n)) {
nv_compute_capability_minor = n;
continue;
}
if (xp.parse_int("amd_simd_per_compute_unit", n)) {
amd_simd_per_compute_unit = n;
continue;
}
if (xp.parse_int("amd_simd_width", n)) {
amd_simd_width = n;
continue;
}
if (xp.parse_int("amd_simd_instruction_width", n)) {
amd_simd_instruction_width = n;
continue;
}
if (xp.parse_str("opencl_platform_version",
opencl_platform_version,
sizeof(opencl_platform_version)
)) {
continue;
}
if (xp.parse_str("opencl_device_version",
opencl_device_version,
sizeof(opencl_device_version)
)) {
continue;
}
if (xp.parse_str("opencl_driver_version",
opencl_driver_version,
sizeof(opencl_driver_version)
)) {
continue;
}
// The following are used only in the
// COPROC_INFO_FILENAME temporary file
if (xp.parse_int("device_num", n)) {
device_num = n;
continue;
}
if (xp.parse_double("peak_flops", peak_flops)) continue;
if (xp.parse_double("opencl_available_ram", opencl_available_ram)) continue;
if (xp.parse_int("opencl_device_index", n)) {
opencl_device_index = n;
continue;
}
if (xp.parse_bool("warn_bad_cuda", warn_bad_cuda)) continue;
}
return ERR_XML_PARSE;
}
int OPENCL_DEVICE_PROP::get_device_version_int() {
int maj, min;
int n = sscanf(
opencl_device_version, "OpenCL %d.%d", &maj, &min
);
if (n != 2) {
return ERR_NOT_FOUND;
}
opencl_device_version_int = 100*maj + min;
return 0;
}
int OPENCL_DEVICE_PROP::get_opencl_driver_revision() {
// gets the OpenCL runtime revision
// Thus far this is only necessary for ATI/AMD because there are bad
// driver sets only distinguisable by the runtime library version.
// Fortunately this info is in the opencl_device_version string.
float rev=0;
char *p=opencl_device_version+sizeof(opencl_device_version)-1;
// find the last opening bracket
while ((p > opencl_device_version) && (*p!='(')) p--;
if (p!=opencl_device_version) {
int n=sscanf(
p, "(%f", &rev
);
// I don't care about errors because for non-ATI GPUs this should
// be zero.
if (n!=1) {
rev=0;
}
}
opencl_driver_revision=floor(rev*100+0.5);
return 0;
}
void OPENCL_DEVICE_PROP::description(char* buf, int buflen, const char* type) {
char s1[256], s2[1024];
int n;
// openCL_device_version may have a trailing space
strlcpy(s1, opencl_device_version, sizeof(s1));
n = (int)strlen(s1) - 1;
if ((n > 0) && (s1[n] == ' ')) s1[n] = '\0';
snprintf(s2, sizeof(s2),
"%.64s (driver version %.64s, device version %.64s, %.0fMB, %.0fMB available, %.0f GFLOPS peak)",
name, opencl_driver_version,
s1, global_mem_size/MEGA,
opencl_available_ram/MEGA, peak_flops/1.e9
);
switch(is_used) {
case COPROC_IGNORED:
snprintf(buf, buflen,
"OpenCL: %s %d (ignored by config): %s",
type, device_num, s2
);
break;
case COPROC_USED:
snprintf(buf, buflen,
"OpenCL: %s %d: %s",
type, device_num, s2
);
break;
case COPROC_UNUSED:
default:
snprintf(buf, buflen,
"OpenCL: %s %d (not used): %s",
type, device_num, s2
);
break;
}
}
////////////////// OPENCL CPU STARTS HERE /////////////////
// CPU OpenCL does not really describe a coprocessor but
// this is here to take advantage of the other OpenCL code.
void OPENCL_CPU_PROP::clear() {
platform_vendor[0] = 0;
opencl_prop.clear();
}
void OPENCL_CPU_PROP::write_xml(MIOFILE& f) {
#ifndef _USING_FCGI_
f.printf(
"<opencl_cpu_prop>\n"
" <platform_vendor>%s</platform_vendor>\n",
platform_vendor
);
opencl_prop.write_xml(f, "opencl_cpu_info");
f.printf("</opencl_cpu_prop>\n");
#endif
}
int OPENCL_CPU_PROP::parse(XML_PARSER& xp) {
int retval;
clear();
while (!xp.get_tag()) {
if (xp.match_tag("/opencl_cpu_prop")) {
if (!strlen(platform_vendor)) return ERR_XML_PARSE;
return 0;
}
if (xp.parse_str("platform_vendor", platform_vendor, sizeof(platform_vendor))) continue;
if (xp.match_tag("opencl_cpu_info")) {
retval = opencl_prop.parse(xp, "/opencl_cpu_info");
if (retval) return retval;
continue;
}
}
return ERR_XML_PARSE;
}
void OPENCL_CPU_PROP::description(char* buf, int buflen) {
char s1[256];
int n;
// openCL_device_version may have a trailing space
strlcpy(s1, opencl_prop.opencl_device_version, sizeof(s1));
n = (int)strlen(s1) - 1;
if ((n > 0) && (s1[n] == ' ')) s1[n] = '\0';
snprintf(buf, buflen,
"OpenCL CPU: %s (OpenCL driver vendor: %s, driver version %s, device version %s)",
opencl_prop.name, platform_vendor, opencl_prop.opencl_driver_version, s1
);
}
Reference in New Issue View Git Blame Copy Permalink