Skip to content

Commit b3ce765

Browse files
chraacchraac
committed
move op key generate function to kOpCaps
1 parent 8b652dd commit b3ce765

File tree

4 files changed

+109
-103
lines changed

4 files changed

+109
-103
lines changed

‎ggml/src/ggml-qnn/backend-ops.cpp

Lines changed: 5 additions & 59 deletions
Original file line numberDiff line numberDiff line change
@@ -52,60 +52,6 @@ namespace {
5252

5353
typedef bool (*ggml_qnn_op_t)(ggml_backend_qnn_device_context * ctx, ggml_tensor * dst);
5454

55-
void append_tensor_dimensions(const ggml_tensor * tensor, std::string & output) {
56-
char buffer[256] = {};
57-
const auto * type_name = qnn::get_ggml_type_name(tensor->type);
58-
int len = 0;
59-
switch (ggml_n_dims(tensor)) {
60-
case 1:
61-
len = snprintf(buffer, sizeof(buffer), "%ld%s", (long) tensor->ne[0], type_name);
62-
break;
63-
case 2:
64-
len = snprintf(buffer, sizeof(buffer), "%ldx%ld%s", (long) tensor->ne[0], (long) tensor->ne[1], type_name);
65-
break;
66-
case 3:
67-
len = snprintf(buffer, sizeof(buffer), "%ldx%ldx%ld%s", (long) tensor->ne[0], (long) tensor->ne[1],
68-
(long) tensor->ne[2], type_name);
69-
break;
70-
case 4:
71-
default:
72-
len = snprintf(buffer, sizeof(buffer), "%ldx%ldx%ldx%ld%s", (long) tensor->ne[0], (long) tensor->ne[1],
73-
(long) tensor->ne[2], (long) tensor->ne[3], type_name);
74-
break;
75-
}
76-
GGML_ASSERT(len > 0 && len < (int) sizeof(buffer));
77-
output.append(buffer, len);
78-
}
79-
80-
void get_graph_key_from_op(const ggml_tensor * op, std::string & output) {
81-
GGML_ASSERT(op->op != GGML_OP_NONE);
82-
output += ggml_op_desc(op);
83-
output += qnn::get_ggml_type_name(op->type);
84-
const auto param_count = qnn::get_qnn_op_input_param_count(op);
85-
for (size_t i = 0; i < param_count; ++i) {
86-
auto * input = op->src[i];
87-
if (!input) {
88-
break;
89-
}
90-
91-
output += '_';
92-
append_tensor_dimensions(input, output);
93-
}
94-
}
95-
96-
void get_op_key_with_src_op_desc(const ggml_tensor * op, std::string & output) {
97-
output += ggml_op_desc(op);
98-
output += '(';
99-
if (op->src[0]) {
100-
output += ggml_op_desc(op->src[0]);
101-
}
102-
for (size_t i = 1; i < GGML_MAX_DIMS && op->src[i]; ++i) {
103-
output += ',';
104-
output += ggml_op_desc(op->src[i]);
105-
}
106-
output += ')';
107-
}
108-
10955
/**
11056
* @brief Generates a unique key for a given computation graph (cgraph).
11157
*
@@ -141,11 +87,11 @@ void get_graph_key_from_cgraph(const ggml_cgraph * cgraph, std::string & output)
14187
}
14288

14389
if (is_start) {
144-
get_graph_key_from_op(cgraph->nodes[0], output);
90+
qnn::get_qnn_op_desc(cgraph->nodes[0], is_start, output);
14591
is_start = false;
14692
} else {
14793
output += '#';
148-
get_op_key_with_src_op_desc(op, output);
94+
qnn::get_qnn_op_desc(op, is_start, output);
14995
}
15096
}
15197
}
@@ -154,7 +100,7 @@ void get_graph_key_from_cgraph(const ggml_cgraph * cgraph, std::string & output)
154100
auto * last_op = cgraph->nodes[cgraph->n_nodes - 1];
155101
output += qnn::get_ggml_type_name(last_op->type);
156102
output += '_';
157-
append_tensor_dimensions(last_op, output);
103+
qnn::append_tensor_shape_and_type(last_op, output);
158104
}
159105
}
160106

@@ -449,7 +395,7 @@ bool device_supports_op(ggml_backend_qnn_device_context * ctx, const ggml_tensor
449395
if (!kQnnSupportedOps[qnn::get_qnn_op_index(op)]) {
450396
#ifndef NDEBUG
451397
std::string op_key;
452-
get_graph_key_from_op(op, op_key);
398+
get_qnn_op_desc(op, true, op_key);
453399
ctx->unsupported_op_count++;
454400
QNN_LOG_DEBUG("[%s][%s]op was unsupported, support/unsupported: %d/%d\n", qnn::get_backend_name(ctx->device),
455401
op_key.c_str(), ctx->supported_op_count.load(), ctx->unsupported_op_count.load());
@@ -460,7 +406,7 @@ bool device_supports_op(ggml_backend_qnn_device_context * ctx, const ggml_tensor
460406
if (!ggnl_qnn_supports_op_tensor(ctx, op)) {
461407
#ifndef NDEBUG
462408
std::string tensor_dims;
463-
append_tensor_dimensions(op, tensor_dims);
409+
append_tensor_shape_and_type(op, tensor_dims);
464410
QNN_LOG_DEBUG("[%s][%s]unsupported tensor(%s), support/unsupported: %d/%d\n",
465411
qnn::get_backend_name(ctx->device), ggml_op_name(op->op), tensor_dims.c_str(),
466412
ctx->supported_op_count.load(), ctx->unsupported_op_count.load());

‎ggml/src/ggml-qnn/ggml-qnn.cpp

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -4,13 +4,13 @@
44
#include <memory>
55
#include <vector>
66

7+
#include "backend-ops.hpp"
8+
#include "backend.hpp"
79
#include "ggml-backend-impl.h"
810
#include "ggml-impl.h"
9-
#include "ggml-qnn/backend-ops.hpp"
10-
#include "ggml-qnn/backend.hpp"
11-
#include "ggml-qnn/logger.hpp"
12-
#include "ggml-qnn/tensor.hpp"
13-
#include "ggml-qnn/utils.hpp"
11+
#include "logger.hpp"
12+
#include "tensor.hpp"
13+
#include "utils.hpp"
1414

1515
// =================================================================================================
1616
//

‎ggml/src/ggml-qnn/op-config-caps.cpp

Lines changed: 91 additions & 36 deletions
Original file line numberDiff line numberDiff line change
@@ -3,30 +3,52 @@
33

44
namespace {
55

6-
using op_constructor_t = std::shared_ptr<qnn::ggml_qnn_op_config> (*)(const ggml_tensor *, const std::string &,
6+
using op_constructor_t = std::shared_ptr<qnn::ggml_qnn_op_config> (*)(const ggml_tensor *, const std::string &,
77
std::shared_ptr<qnn::qnn_instance>);
8-
using op_dims_calc_func_t = void (*)(const std::vector<qnn::ggml_dimension_array_t> & input_dims,
9-
qnn::ggml_dimension_array_t & output_dims);
108

11-
void element_wise_op_dims(const std::vector<qnn::ggml_dimension_array_t> & input_dims,
12-
qnn::ggml_dimension_array_t & output_dims) {
13-
for (size_t i = 1; i < std::size(output_dims); i++) {
14-
output_dims[i] = input_dims.front()[i];
9+
using op_description_generator_t = void (*)(const ggml_tensor * op, bool append_dimensions, std::string & output);
10+
11+
void get_graph_key_from_op(const ggml_tensor * op, std::string & output) {
12+
GGML_ASSERT(op->op != GGML_OP_NONE);
13+
output += ggml_op_desc(op);
14+
output += qnn::get_ggml_type_name(op->type);
15+
for (size_t i = 0; i < GGML_MAX_SRC && op->src[i]; ++i) {
16+
auto * input = op->src[i];
17+
if (!input) {
18+
break;
19+
}
20+
21+
output += '_';
22+
qnn::append_tensor_shape_and_type(input, output);
1523
}
1624
}
1725

18-
void mat_mul_op_dims(const std::vector<qnn::ggml_dimension_array_t> & input_dims,
19-
qnn::ggml_dimension_array_t & output_dims) {
20-
GGML_ASSERT(input_dims.size() == 2);
21-
output_dims[0] = input_dims.front()[1];
22-
output_dims[1] = input_dims.back()[1];
26+
void get_op_key_with_src_op_desc(const ggml_tensor * op, std::string & output) {
27+
output += ggml_op_desc(op);
28+
output += '(';
29+
if (op->src[0]) {
30+
output += ggml_op_desc(op->src[0]);
31+
}
32+
for (size_t i = 1; i < GGML_MAX_SRC && op->src[i]; ++i) {
33+
output += ',';
34+
output += ggml_op_desc(op->src[i]);
35+
}
36+
output += ')';
37+
}
38+
39+
void generic_get_op_desc(const ggml_tensor * op, bool append_dimensions, std::string & output) {
40+
if (append_dimensions) {
41+
get_graph_key_from_op(op, output);
42+
} else {
43+
get_op_key_with_src_op_desc(op, output);
44+
}
2345
}
2446

2547
struct qnn_op_caps_t {
26-
const char * qnn_op_name = nullptr;
27-
const size_t input_param_count = 0;
28-
op_dims_calc_func_t calc_dims_func = nullptr;
29-
const char * qnn_param_name = nullptr;
48+
const char * qnn_op_name = nullptr;
49+
const size_t input_param_count = 0;
50+
op_description_generator_t get_desc = nullptr;
51+
const char * qnn_param_name = nullptr;
3052
};
3153

3254
constexpr const qnn_op_caps_t kOpCaps[] = {
@@ -36,40 +58,40 @@ constexpr const qnn_op_caps_t kOpCaps[] = {
3658
// GGML_OP_ADD
3759
QNN_OP_ELEMENT_WISE_ADD, // qnn_op_name
3860
2, // input_param_count
39-
element_wise_op_dims, // calc_dims_func
61+
generic_get_op_desc, // get_desc
4062
},
4163
{}, // GGML_OP_ADD1
4264
{}, // GGML_OP_ACC
4365
{
4466
// GGML_OP_SUB
4567
QNN_OP_ELEMENT_WISE_SUBTRACT, // qnn_op_name
4668
2, // input_param_count
47-
element_wise_op_dims, // calc_dims_func
69+
generic_get_op_desc, // get_desc
4870
},
4971
{
5072
// GGML_OP_MUL
5173
QNN_OP_ELEMENT_WISE_MULTIPLY, // qnn_op_name
5274
2, // input_param_count
53-
element_wise_op_dims, // calc_dims_func
75+
generic_get_op_desc, // get_desc
5476
},
5577
{
5678
// GGML_OP_DIV
5779
QNN_OP_ELEMENT_WISE_DIVIDE, // qnn_op_name
5880
2, // input_param_count
59-
element_wise_op_dims, // calc_dims_func
81+
generic_get_op_desc, // get_desc
6082
},
6183
{}, // GGML_OP_SQR
6284
{
6385
// GGML_OP_SQRT
6486
QNN_OP_ELEMENT_WISE_SQUARE_ROOT, // qnn_op_name
6587
1, // input_param_count
66-
element_wise_op_dims, // calc_dims_func
88+
generic_get_op_desc, // get_desc
6789
},
6890
{
6991
// GGML_OP_LOG
7092
QNN_OP_ELEMENT_WISE_LOG, // qnn_op_name
7193
1, // input_param_count
72-
element_wise_op_dims, // calc_dims_func
94+
generic_get_op_desc, // get_desc
7395
},
7496
{}, // GGML_OP_SIN
7597
{}, // GGML_OP_COS
@@ -87,16 +109,16 @@ constexpr const qnn_op_caps_t kOpCaps[] = {
87109
// GGML_OP_RMS_NORM
88110
QNN_OP_RMS_NORM, // qnn_op_name
89111
1, // input_param_count
90-
nullptr, // TODO: calc_dims_func
112+
generic_get_op_desc, // get_desc
91113
QNN_OP_RMS_NORM_PARAM_EPSILON, // qnn_param_name
92114
},
93115
{}, // GGML_OP_RMS_NORM_BACK
94116
{}, // GGML_OP_GROUP_NORM
95117
{
96118
// GGML_OP_MUL_MAT
97-
QNN_OP_MAT_MUL, // qnn_op_name
98-
2, // input_param_count
99-
mat_mul_op_dims, // calc_dims_func
119+
QNN_OP_MAT_MUL, // qnn_op_name
120+
2, // input_param_count
121+
generic_get_op_desc, // get_desc
100122
},
101123
{}, // GGML_OP_MUL_MAT_ID
102124
{}, // GGML_OP_OUT_PROD
@@ -106,9 +128,9 @@ constexpr const qnn_op_caps_t kOpCaps[] = {
106128
{}, // GGML_OP_CONT
107129
{
108130
// GGML_OP_RESHAPE
109-
QNN_OP_RESHAPE, // qnn_op_name
110-
1, // input_param_count
111-
nullptr, // TODO: calc_dims_func
131+
QNN_OP_RESHAPE, // qnn_op_name
132+
1, // input_param_count
133+
generic_get_op_desc, // get_desc
112134
},
113135
{}, // GGML_OP_VIEW
114136
{}, // GGML_OP_PERMUTE
@@ -178,9 +200,9 @@ constexpr const qnn_op_caps_t kOpCaps[] = {
178200
{}, // GGML_UNARY_OP_SIGMOID
179201
{
180202
// GGML_UNARY_OP_GELU
181-
QNN_OP_GELU, // qnn_op_name
182-
1, // input_param_count
183-
nullptr, // TODO: calc_dims_func
203+
QNN_OP_GELU, // qnn_op_name
204+
1, // input_param_count
205+
generic_get_op_desc, // get_desc
184206
},
185207
{}, // GGML_UNARY_OP_GELU_QUICK
186208
{}, // GGML_UNARY_OP_SILU
@@ -189,12 +211,12 @@ constexpr const qnn_op_caps_t kOpCaps[] = {
189211
{}, // GGML_UNARY_OP_EXP
190212
};
191213

192-
static_assert(kOpCaps[GGML_OP_NONE].calc_dims_func == nullptr, "GGML_OP_NONE should not have calc_dims_func function");
193-
static_assert(kOpCaps[GGML_OP_ADD].calc_dims_func == element_wise_op_dims,
214+
static_assert(kOpCaps[GGML_OP_NONE].get_desc == nullptr, "GGML_OP_NONE should not have get_desc function");
215+
static_assert(kOpCaps[GGML_OP_ADD].get_desc == generic_get_op_desc,
194216
"GGML_OP_ADD does not have element_wise_op_dims function");
195-
static_assert(kOpCaps[GGML_OP_MUL_MAT].calc_dims_func == mat_mul_op_dims,
217+
static_assert(kOpCaps[GGML_OP_MUL_MAT].get_desc == generic_get_op_desc,
196218
"GGML_OP_ADD does not have element_wise_op_dims function");
197-
static_assert(kOpCaps[GGML_OP_LOG].calc_dims_func == element_wise_op_dims,
219+
static_assert(kOpCaps[GGML_OP_LOG].get_desc == generic_get_op_desc,
198220
"GGML_OP_LOG does not have element_wise_op_dims function");
199221
static_assert(kOpCaps[GGML_OP_COUNT + GGML_UNARY_OP_GELU].input_param_count == 1,
200222
"GGML_UNARY_OP_GELU does not have 1 input parameter");
@@ -368,6 +390,31 @@ static_assert(std::size(kOpConstructors) == (GGML_OP_COUNT + GGML_UNARY_OP_COUNT
368390

369391
namespace qnn {
370392

393+
void append_tensor_shape_and_type(const ggml_tensor * tensor, std::string & output) {
394+
char buffer[256] = {};
395+
const auto * type_name = qnn::get_ggml_type_name(tensor->type);
396+
int len = 0;
397+
switch (ggml_n_dims(tensor)) {
398+
case 1:
399+
len = snprintf(buffer, sizeof(buffer), "%ld%s", (long) tensor->ne[0], type_name);
400+
break;
401+
case 2:
402+
len = snprintf(buffer, sizeof(buffer), "%ldx%ld%s", (long) tensor->ne[0], (long) tensor->ne[1], type_name);
403+
break;
404+
case 3:
405+
len = snprintf(buffer, sizeof(buffer), "%ldx%ldx%ld%s", (long) tensor->ne[0], (long) tensor->ne[1],
406+
(long) tensor->ne[2], type_name);
407+
break;
408+
case 4:
409+
default:
410+
len = snprintf(buffer, sizeof(buffer), "%ldx%ldx%ldx%ld%s", (long) tensor->ne[0], (long) tensor->ne[1],
411+
(long) tensor->ne[2], (long) tensor->ne[3], type_name);
412+
break;
413+
}
414+
GGML_ASSERT(len > 0 && len < (int) sizeof(buffer));
415+
output.append(buffer, len);
416+
}
417+
371418
size_t get_qnn_op_index(const ggml_tensor * tensor) {
372419
if (tensor->op == GGML_OP_UNARY) {
373420
return kGgmlUnaryOpStart + ggml_get_unary_op(tensor);
@@ -389,6 +436,14 @@ size_t get_qnn_op_input_param_count(const ggml_tensor * op) {
389436
return kOpCaps[op_index].input_param_count;
390437
}
391438

439+
void get_qnn_op_desc(const ggml_tensor * op, bool append_dimensions, std::string & output) {
440+
auto op_index = get_qnn_op_index(op);
441+
GGML_ASSERT(op_index < std::size(kOpCaps));
442+
auto get_desc = kOpCaps[op_index].get_desc;
443+
GGML_ASSERT(get_desc);
444+
get_desc(op, append_dimensions, output);
445+
}
446+
392447
std::shared_ptr<ggml_qnn_op_config> create_op(const ggml_tensor * op, const std::string & name,
393448
std::shared_ptr<qnn_instance> qnn_instance) {
394449
auto op_index = get_qnn_op_index(op);

‎ggml/src/ggml-qnn/op-config.hpp

Lines changed: 8 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -14,9 +14,14 @@ namespace qnn {
1414

1515
constexpr const size_t kGgmlUnaryOpStart = GGML_OP_COUNT;
1616

17-
size_t get_qnn_op_index(const ggml_tensor * tensor);
18-
const char * get_qnn_op_name(const ggml_tensor * op);
19-
size_t get_qnn_op_input_param_count(const ggml_tensor * op);
17+
// TODO: move to a better place
18+
void append_tensor_shape_and_type(const ggml_tensor * tensor, std::string & output);
19+
20+
size_t get_qnn_op_index(const ggml_tensor * tensor);
21+
const char * get_qnn_op_name(const ggml_tensor * op);
22+
size_t get_qnn_op_input_param_count(const ggml_tensor * op);
23+
void get_qnn_op_desc(const ggml_tensor * op, bool append_dimensions, std::string & output);
24+
2025
std::shared_ptr<ggml_qnn_op_config> create_op(const ggml_tensor * op, const std::string & name,
2126
std::shared_ptr<qnn_instance> qnn_instance);
2227

0 commit comments

Comments
 (0)