Skip to content

Commit 991f8aa

Browse files
qnixsynapseqnixsynapse
authored
SYCL: Fix and switch to GGML_LOG system instead of fprintf (#10579)
* Switched to GGML_LOG * Fix missing semicolon
1 parent 4cb003d commit 991f8aa

File tree

1 file changed

+51
-39
lines changed

1 file changed

+51
-39
lines changed

‎ggml/src/ggml-sycl/ggml-sycl.cpp

Lines changed: 51 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -47,24 +47,24 @@ static ggml_sycl_device_info ggml_sycl_init() {
4747

4848
info.device_count = dpct::dev_mgr::instance().device_count();
4949
if (info.device_count == 0) {
50-
fprintf(stderr, "%s: failed to initialize " GGML_SYCL_NAME ": %s\n", __func__);
50+
GGML_LOG_ERROR("%s: failed to initialize " GGML_SYCL_NAME ": %s\n", __func__);
5151
return info;
5252
}
5353

5454
GGML_ASSERT(info.device_count <= GGML_SYCL_MAX_DEVICES);
5555

5656
int64_t total_vram = 0;
5757
#if defined(GGML_SYCL_FORCE_MMQ)
58-
fprintf(stderr, "%s: GGML_SYCL_FORCE_MMQ: yes\n", __func__);
58+
GGML_LOG_INFO("%s: GGML_SYCL_FORCE_MMQ: yes\n", __func__);
5959
#else
60-
fprintf(stderr, "%s: GGML_SYCL_FORCE_MMQ: no\n", __func__);
60+
GGML_LOG_INFO("%s: GGML_SYCL_FORCE_MMQ: no\n", __func__);
6161
#endif
6262
#if defined(SYCL_USE_XMX)
63-
fprintf(stderr, "%s: SYCL_USE_XMX: yes\n", __func__);
63+
GGML_LOG_INFO("%s: SYCL_USE_XMX: yes\n", __func__);
6464
#else
65-
fprintf(stderr, "%s: SYCL_USE_XMX: no\n", __func__);
65+
GGML_LOG_INFO("%s: SYCL_USE_XMX: no\n", __func__);
6666
#endif
67-
fprintf(stderr, "%s: found %d " GGML_SYCL_NAME " devices:\n", __func__, info.device_count);
67+
GGML_LOG_INFO("%s: found %d " GGML_SYCL_NAME " devices:\n", __func__, info.device_count);
6868

6969
for (int i = 0; i < info.device_count; ++i) {
7070
info.devices[i].vmm = 0;
@@ -110,7 +110,7 @@ void print_device_detail(int id, sycl::device &device, std::string device_type)
110110

111111
auto global_mem_size = prop.get_global_mem_size()/1000000;
112112

113-
fprintf(stderr, "|%2d|%19s|%39s|%7s|%7d|%8d|%5d|%6luM|%21s|\n", id, device_type.c_str(),
113+
GGML_LOG_INFO("|%2d|%19s|%39s|%7s|%7d|%8d|%5d|%6luM|%21s|\n", id, device_type.c_str(),
114114
name.c_str(), version.c_str(), prop.get_max_compute_units(),
115115
prop.get_max_work_group_size(), prop.get_max_sub_group_size(),
116116
global_mem_size, device.get_info<sycl::info::device::driver_version>().c_str());
@@ -120,19 +120,30 @@ void ggml_backend_sycl_print_sycl_devices() {
120120
GGML_SYCL_DEBUG("[SYCL] call ggml_backend_sycl_print_sycl_devices\n");
121121
int device_count = dpct::dev_mgr::instance().device_count();
122122
std::map<std::string, size_t> DeviceNums;
123-
fprintf(stderr, "found %d SYCL devices:\n", device_count);
124-
fprintf(stderr, "| | | | |Max | |Max |Global | |\n");
125-
fprintf(stderr, "| | | | |compute|Max work|sub |mem | |\n");
126-
fprintf(stderr, "|ID| Device Type| Name|Version|units |group |group|size | Driver version|\n");
127-
fprintf(stderr, "|--|-------------------|---------------------------------------|-------|-------|--------|-----|-------|---------------------|\n");
123+
GGML_LOG_INFO("Found %d SYCL devices:\n", device_count);
124+
125+
GGML_LOG_INFO(
126+
"| | | | "
127+
" |Max | |Max |Global | |\n");
128+
GGML_LOG_INFO(
129+
"| | | | "
130+
" |compute|Max work|sub |mem | |\n");
131+
GGML_LOG_INFO(
132+
"|ID| Device Type| "
133+
"Name|Version|units |group |group|size | Driver version|\n");
134+
GGML_LOG_INFO(
135+
"|--|-------------------|---------------------------------------|------"
136+
"-|-------|--------|-----|-------|---------------------|\n");
137+
128138
for (int id = 0; id < device_count; ++id) {
129-
sycl::device device = dpct::dev_mgr::instance().get_device(id);
130-
sycl::backend backend = device.get_backend();
131-
std::string backend_type = get_device_backend_and_type(device);
132-
int type_id=DeviceNums[backend_type]++;
133-
std::stringstream device_type;
134-
device_type << "[" << backend_type << ":" << std::to_string(type_id) << "]";
135-
print_device_detail(id, device, device_type.str());
139+
sycl::device device = dpct::dev_mgr::instance().get_device(id);
140+
sycl::backend backend = device.get_backend();
141+
std::string backend_type = get_device_backend_and_type(device);
142+
int type_id = DeviceNums[backend_type]++;
143+
std::stringstream device_type;
144+
device_type << "[" << backend_type << ":" << std::to_string(type_id)
145+
<< "]";
146+
print_device_detail(id, device, device_type.str());
136147
}
137148
}
138149

@@ -154,15 +165,14 @@ static void ggml_check_sycl() try {
154165
static bool initialized = false;
155166

156167
if (!initialized) {
157-
fprintf(stderr, "[SYCL] call ggml_check_sycl\n");
168+
GGML_LOG_INFO("[SYCL] call ggml_check_sycl\n");
158169
g_ggml_sycl_debug = get_sycl_env("GGML_SYCL_DEBUG", 0);
159-
160-
fprintf(stderr, "%s: GGML_SYCL_DEBUG: %d\n", __func__, g_ggml_sycl_debug);
170+
GGML_LOG_INFO("%s: GGML_SYCL_DEBUG: %d\n", __func__, g_ggml_sycl_debug);
161171

162172
#if defined(GGML_SYCL_F16)
163-
fprintf(stderr, "%s: GGML_SYCL_F16: yes\n", __func__);
173+
GGML_LOG_INFO("%s: GGML_SYCL_F16: yes\n", __func__);
164174
#else
165-
fprintf(stderr, "%s: GGML_SYCL_F16: no\n", __func__);
175+
GGML_LOG_INFO("%s: GGML_SYCL_F16: no\n", __func__);
166176
#endif
167177

168178
/* NOT REMOVE, keep it for next optimize for XMX.
@@ -180,9 +190,10 @@ static void ggml_check_sycl() try {
180190
return;
181191
}
182192
GGML_ASSERT(g_all_sycl_device_count <= GGML_SYCL_MAX_DEVICES);
183-
ggml_backend_sycl_print_sycl_devices();
193+
184194
initialized = true;
185195
g_sycl_loaded = true;
196+
ggml_backend_sycl_print_sycl_devices();
186197
}
187198
}
188199
catch (sycl::exception const &exc) {
@@ -205,7 +216,7 @@ inline void check_allow_gpu_index(const int device_index) {
205216
__func__,
206217
device_index,
207218
ggml_sycl_info().device_count - 1);
208-
fprintf(stderr, "%s\n", error_buf);
219+
GGML_LOG_ERROR("%s\n", error_buf);
209220
assert(false);
210221
}
211222
}
@@ -475,8 +486,8 @@ ggml_backend_sycl_buffer_type_alloc_buffer(ggml_backend_buffer_type_t buft,
475486
SYCL_CHECK(CHECK_TRY_ERROR(dev_ptr = (void *)sycl::malloc_device(
476487
size, *stream)));
477488
if (!dev_ptr) {
478-
fprintf(stderr, "%s: can't malloc %lu Bytes memory on device", __func__, size);
479-
return nullptr;
489+
GGML_LOG_ERROR("%s: can't allocate %lu Bytes of memory on device\n", __func__, size);
490+
return nullptr;
480491
}
481492
ggml_backend_sycl_buffer_context * ctx = new ggml_backend_sycl_buffer_context(buft_ctx->device, dev_ptr, buft_ctx->stream);
482493
return ggml_backend_buffer_init(buft, ggml_backend_sycl_buffer_interface, ctx, size);
@@ -752,7 +763,7 @@ ggml_backend_sycl_split_buffer_init_tensor(ggml_backend_buffer_t buffer,
752763
size, *stream)));
753764
if (!buf) {
754765
char err_buf[1024];
755-
snprintf(err_buf, 1023, "%s: can't malloc %lu Bytes memory on device", __func__, size);
766+
snprintf(err_buf, 1023, "%s: can't allocate %lu Bytes of memory on device\n", __func__, size);
756767
throw std::runtime_error(err_buf);
757768
}
758769
// set padding to 0 to avoid possible NaN values
@@ -1142,17 +1153,18 @@ struct ggml_sycl_pool_leg : public ggml_sycl_pool {
11421153
CHECK_TRY_ERROR(ptr = (void *)sycl::malloc_device(
11431154
look_ahead_size, *qptr)));
11441155
if (!ptr) {
1145-
fprintf(stderr, "%s: can't malloc %lu Bytes memory on device", __func__, look_ahead_size);
1156+
GGML_LOG_ERROR("%s: can't allocate %lu Bytes of memory on device/GPU\n", __func__, look_ahead_size);
11461157
return nullptr;
11471158
}
11481159

11491160
*actual_size = look_ahead_size;
11501161
pool_size += look_ahead_size;
11511162

1152-
#ifdef DEBUG_SYCL_MALLOC
1153-
fprintf(stderr, "%s[%d]: %d buffers, max_size = %u MB, pool_size = %u MB, requested %u MB\n", __func__, id, nnz,
1163+
#ifdef DEBUG_SYCL_MALLOC
1164+
GGML_LOG_DEBUG("%s[%d]: %d buffers, max_size = %u MB, pool_size = %u MB, requested %u MB\n", __func__, id, nnz,
11541165
(uint32_t)(max_size/1024/1024), (uint32_t)(g_sycl_pool_size[id]/1024/1024), (uint32_t)(size/1024/1024));
1155-
#endif
1166+
#endif
1167+
11561168
// GGML_SYCL_DEBUG("ggml_sycl_pool_malloc_leg look_ahead_size=%lu, return %p\n", look_ahead_size, ptr);
11571169
return ptr;
11581170
}
@@ -1166,7 +1178,7 @@ struct ggml_sycl_pool_leg : public ggml_sycl_pool {
11661178
return;
11671179
}
11681180
}
1169-
fprintf(stderr, "WARNING: sycl buffer pool full, increase MAX_sycl_BUFFERS\n");
1181+
GGML_LOG_WARN("WARNING: sycl buffer pool full, increase MAX_sycl_BUFFERS\n");
11701182
SYCL_CHECK(CHECK_TRY_ERROR(sycl::free(ptr, *qptr)));
11711183
pool_size -= size;
11721184
}
@@ -2437,7 +2449,7 @@ static void ggml_sycl_op_get_rows(ggml_backend_sycl_context & ctx, const ggml_te
24372449
break;
24382450
default:
24392451
// TODO: k-quants
2440-
fprintf(stderr, "%s: unsupported type: %s\n", __func__, ggml_type_name(src0->type));
2452+
GGML_LOG_ERROR("%s: unsupported type: %s\n", __func__, ggml_type_name(src0->type));
24412453
GGML_ABORT("fatal error");
24422454
break;
24432455
}
@@ -3750,7 +3762,7 @@ static void ggml_sycl_cpy(ggml_backend_sycl_context & ctx, const ggml_tensor *sr
37503762
} else if (src0->type == GGML_TYPE_I32 && src1->type == GGML_TYPE_I32) {
37513763
ggml_cpy_i32_i32_sycl (src0_ddc, src1_ddc, ne, ne00, ne01, ne02, nb00, nb01, nb02, nb03, ne10, ne11, ne12, nb10, nb11, nb12, nb13, main_stream);
37523764
} else {
3753-
fprintf(stderr, "%s: unsupported type combination (%s to %s)\n", __func__,
3765+
GGML_LOG_ERROR("%s: unsupported type combination (%s to %s)\n", __func__,
37543766
ggml_type_name(src0->type), ggml_type_name(src1->type));
37553767
GGML_ABORT("fatal error");
37563768
}
@@ -3825,7 +3837,7 @@ void ggml_sycl_set_main_device(const int main_device) try {
38253837
dpct::device_info prop;
38263838
SYCL_CHECK(CHECK_TRY_ERROR(dpct::get_device_info(
38273839
prop, dpct::dev_mgr::instance().get_device(main_device))));
3828-
fprintf(stderr, "Using device %d (%s) as main device\n",
3840+
GGML_LOG_INFO("Using device %d (%s) as main device\n",
38293841
main_device, prop.get_name());
38303842
}
38313843
}
@@ -4172,7 +4184,7 @@ static ggml_status ggml_backend_sycl_graph_compute(ggml_backend_t backend, ggml_
41724184
#endif
41734185
bool ok = ggml_sycl_compute_forward(*sycl_ctx, node);
41744186
if (!ok) {
4175-
fprintf(stderr, "%s: error: op not supported %s (%s)\n", __func__, node->name, ggml_op_name(node->op));
4187+
GGML_LOG_ERROR("%s: error: op not supported %s (%s)\n", __func__, node->name, ggml_op_name(node->op));
41764188
}
41774189
GGML_ASSERT(ok);
41784190
}
@@ -4672,7 +4684,7 @@ ggml_backend_t ggml_backend_sycl_init(int device) {
46724684

46734685
ggml_backend_sycl_context * ctx = new ggml_backend_sycl_context(device);
46744686
if (ctx == nullptr) {
4675-
fprintf(stderr, "%s: error: failed to allocate context\n", __func__);
4687+
GGML_LOG_ERROR("%s: error: failed to allocate context\n", __func__);
46764688
return nullptr;
46774689
};
46784690

0 commit comments

Comments
 (0)