ggml_reshape_2d(ctx, im2col, im2col->ne[0], im2col->ne[3] * im2col->ne[2] * im2col->ne[1]), // [N, OH, OW, IC * KH * KW] => [N*OH*OW, IC * KH * KW]
ggml_reshape_2d(ctx, a, (a->ne[0] * a->ne[1] * a->ne[2]), a->ne[3])); // [OC，IC, KH, KW] => [OC, IC * KH * KW]
- result = ggml_reshape_4d(ctx, result, im2col->ne[1], im2col->ne[2], a->ne[3], im2col->ne[3]); // [N, OC, OH, OW]
+ result = ggml_reshape_4d(ctx, result, im2col->ne[1], im2col->ne[2], im2col->ne[3], a->ne[3]); // [OC, N, OH, OW]
+ result = ggml_cont(ctx, ggml_permute(ctx, result, 0, 1, 3, 2)); // [N, OC, OH, OW]
+
return result;
}
static void ggml_compute_forward_dup_same_cont(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_nelements(dst) == ggml_nelements(src0));
GGML_ASSERT(ggml_is_contiguous(dst) && ggml_is_contiguous(src0));
GGML_ASSERT(src0->type == dst->type);
}
static void ggml_compute_forward_dup_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_nelements(dst) == ggml_nelements(src0));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
const int nth = params->nth; // number of threads
if (ggml_is_contiguous(src0) && ggml_is_contiguous(dst) && src0->type == dst->type) {
- ggml_compute_forward_dup_same_cont(params, src0, dst);
+ ggml_compute_forward_dup_same_cont(params, dst);
return;
}
static void ggml_compute_forward_dup_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_nelements(dst) == ggml_nelements(src0));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
const int nth = params->nth; // number of threads
if (ggml_is_contiguous(src0) && ggml_is_contiguous(dst) && src0->type == dst->type) {
- ggml_compute_forward_dup_same_cont(params, src0, dst);
+ ggml_compute_forward_dup_same_cont(params, dst);
return;
}
// A simplified version of ggml_compute_forward_dup that doesn't do float upcasting, and just plain old memcpy.
static void ggml_compute_forward_dup_bytes(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_nelements(dst) == ggml_nelements(src0));
GGML_ASSERT(src0->type == dst->type);
}
if (ggml_is_contiguous(src0) && ggml_is_contiguous(dst)) {
- ggml_compute_forward_dup_same_cont(params, src0, dst);
+ ggml_compute_forward_dup_same_cont(params, dst);
return;
}
static void ggml_compute_forward_dup(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
if (src0->type == dst->type) {
- ggml_compute_forward_dup_bytes(params, src0, dst);
+ ggml_compute_forward_dup_bytes(params, dst);
return;
}
switch (src0->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_dup_f16(params, src0, dst);
+ ggml_compute_forward_dup_f16(params, dst);
} break;
case GGML_TYPE_F32:
{
- ggml_compute_forward_dup_f32(params, src0, dst);
+ ggml_compute_forward_dup_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_add_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_can_repeat(src1, src0) && ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_add_f16_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, src1) && ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_add_f16_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, src1) && ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_add_q_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, src1) && ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_add(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
if (src1->type == GGML_TYPE_F32) {
- ggml_compute_forward_add_f32(params, src0, src1, dst);
+ ggml_compute_forward_add_f32(params, dst);
}
else {
GGML_ASSERT(false);
case GGML_TYPE_F16:
{
if (src1->type == GGML_TYPE_F16) {
- ggml_compute_forward_add_f16_f16(params, src0, src1, dst);
+ ggml_compute_forward_add_f16_f16(params, dst);
}
else if (src1->type == GGML_TYPE_F32) {
- ggml_compute_forward_add_f16_f32(params, src0, src1, dst);
+ ggml_compute_forward_add_f16_f32(params, dst);
}
else {
GGML_ASSERT(false);
case GGML_TYPE_IQ1_S:
case GGML_TYPE_IQ4_NL:
{
- ggml_compute_forward_add_q_f32(params, src0, src1, dst);
+ ggml_compute_forward_add_q_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_add1_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
GGML_ASSERT(ggml_is_scalar(src1));
static void ggml_compute_forward_add1_f16_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
GGML_ASSERT(ggml_is_scalar(src1));
static void ggml_compute_forward_add1_f16_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
GGML_ASSERT(ggml_is_scalar(src1));
static void ggml_compute_forward_add1_q_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
GGML_ASSERT(ggml_is_scalar(src1));
static void ggml_compute_forward_add1(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_add1_f32(params, src0, src1, dst);
+ ggml_compute_forward_add1_f32(params, dst);
} break;
case GGML_TYPE_F16:
{
if (src1->type == GGML_TYPE_F16) {
- ggml_compute_forward_add1_f16_f16(params, src0, src1, dst);
+ ggml_compute_forward_add1_f16_f16(params, dst);
}
else if (src1->type == GGML_TYPE_F32) {
- ggml_compute_forward_add1_f16_f32(params, src0, src1, dst);
+ ggml_compute_forward_add1_f16_f32(params, dst);
}
else {
GGML_ASSERT(false);
case GGML_TYPE_IQ1_S:
case GGML_TYPE_IQ4_NL:
{
- ggml_compute_forward_add1_q_f32(params, src0, src1, dst);
+ ggml_compute_forward_add1_q_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_acc_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
GGML_ASSERT(ggml_is_contiguous(dst) && ggml_is_contiguous(src0));
static void ggml_compute_forward_acc(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_acc_f32(params, src0, src1, dst);
+ ggml_compute_forward_acc_f32(params, dst);
} break;
case GGML_TYPE_F16:
case GGML_TYPE_Q4_0:
static void ggml_compute_forward_sub_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, src1) && ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_sub(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_sub_f32(params, src0, src1, dst);
+ ggml_compute_forward_sub_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_mul_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_can_repeat(src1, src0) && ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_mul(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(src1->type == GGML_TYPE_F32 && "only f32 src1 supported for now");
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_mul_f32(params, src0, src1, dst);
+ ggml_compute_forward_mul_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_div_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_can_repeat(src1, src0) && ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_div(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_div_f32(params, src0, src1, dst);
+ ggml_compute_forward_div_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_sqr_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_sqr(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_sqr_f32(params, src0, dst);
+ ggml_compute_forward_sqr_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_sqrt_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_sqrt(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_sqrt_f32(params, src0, dst);
+ ggml_compute_forward_sqrt_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_log_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(params->ith == 0);
GGML_ASSERT(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_log(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_log_f32(params, src0, dst);
+ ggml_compute_forward_log_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_sum_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_is_scalar(dst));
static void ggml_compute_forward_sum_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_is_scalar(dst));
static void ggml_compute_forward_sum(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_sum_f32(params, src0, dst);
+ ggml_compute_forward_sum_f32(params, dst);
} break;
case GGML_TYPE_F16:
{
- ggml_compute_forward_sum_f16(params, src0, dst);
+ ggml_compute_forward_sum_f16(params, dst);
} break;
default:
{
static void ggml_compute_forward_sum_rows_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_sum_rows(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_sum_rows_f32(params, src0, dst);
+ ggml_compute_forward_sum_rows_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_mean_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_mean(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_mean_f32(params, src0, dst);
+ ggml_compute_forward_mean_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_argmax_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_argmax(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_argmax_f32(params, src0, dst);
+ ggml_compute_forward_argmax_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_repeat_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(params->ith == 0);
GGML_ASSERT(ggml_can_repeat(src0, dst));
static void ggml_compute_forward_repeat_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(params->ith == 0);
GGML_ASSERT(ggml_can_repeat(src0, dst));
static void ggml_compute_forward_repeat(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F16:
case GGML_TYPE_I16:
{
- ggml_compute_forward_repeat_f16(params, src0, dst);
+ ggml_compute_forward_repeat_f16(params, dst);
} break;
case GGML_TYPE_F32:
case GGML_TYPE_I32:
{
- ggml_compute_forward_repeat_f32(params, src0, dst);
+ ggml_compute_forward_repeat_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_repeat_back_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(params->ith == 0);
GGML_ASSERT(ggml_can_repeat(dst, src0));
static void ggml_compute_forward_repeat_back(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_repeat_back_f32(params, src0, dst);
+ ggml_compute_forward_repeat_back_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_concat_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_concat(
const struct ggml_compute_params* params,
- const struct ggml_tensor* src0,
- const struct ggml_tensor* src1,
struct ggml_tensor* dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
case GGML_TYPE_I32:
{
- ggml_compute_forward_concat_f32(params, src0, src1, dst);
+ ggml_compute_forward_concat_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_abs_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_abs(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_abs_f32(params, src0, dst);
+ ggml_compute_forward_abs_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_sgn_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_sgn(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_sgn_f32(params, src0, dst);
+ ggml_compute_forward_sgn_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_neg_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_neg(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_neg_f32(params, src0, dst);
+ ggml_compute_forward_neg_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_step_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_step(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_step_f32(params, src0, dst);
+ ggml_compute_forward_step_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_tanh_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_tanh(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_tanh_f32(params, src0, dst);
+ ggml_compute_forward_tanh_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_elu_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_elu(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_elu_f32(params, src0, dst);
+ ggml_compute_forward_elu_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_relu_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_relu(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_relu_f32(params, src0, dst);
+ ggml_compute_forward_relu_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_gelu_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_is_contiguous_except_dim_1(src0));
GGML_ASSERT(ggml_is_contiguous_except_dim_1(dst));
GGML_ASSERT(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_gelu(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_gelu_f32(params, src0, dst);
+ ggml_compute_forward_gelu_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_gelu_quick_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_is_contiguous_except_dim_1(src0));
GGML_ASSERT(ggml_is_contiguous_except_dim_1(dst));
GGML_ASSERT(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_gelu_quick(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_gelu_quick_f32(params, src0, dst);
+ ggml_compute_forward_gelu_quick_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_silu_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_is_contiguous_except_dim_1(src0));
GGML_ASSERT(ggml_is_contiguous_except_dim_1(dst));
GGML_ASSERT(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_silu(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_silu_f32(params, src0, dst);
+ ggml_compute_forward_silu_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_leaky_relu_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_leaky_relu(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_leaky_relu_f32(params, src0, dst);
+ ggml_compute_forward_leaky_relu_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_silu_back_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * grad,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * grad = dst->src[1];
+
GGML_ASSERT(ggml_is_contiguous_except_dim_1(grad));
GGML_ASSERT(ggml_is_contiguous_except_dim_1(src0));
GGML_ASSERT(ggml_is_contiguous_except_dim_1(dst));
static void ggml_compute_forward_silu_back(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * grad,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_silu_back_f32(params, src0, grad, dst);
+ ggml_compute_forward_silu_back_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_hardswish_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
}
static void ggml_compute_forward_hardswish(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_hardswish_f32(params, src0, dst);
+ ggml_compute_forward_hardswish_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_hardsigmoid_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_hardsigmoid(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_hardsigmoid_f32(params, src0, dst);
+ ggml_compute_forward_hardsigmoid_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_norm_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_norm(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_norm_f32(params, src0, dst);
+ ggml_compute_forward_norm_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_rms_norm_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_rms_norm(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_rms_norm_f32(params, src0, dst);
+ ggml_compute_forward_rms_norm_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_rms_norm_back_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst) && ggml_are_same_shape(src0, src1));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_rms_norm_back(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_rms_norm_back_f32(params, src0, src1, dst);
+ ggml_compute_forward_rms_norm_back_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_group_norm_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_group_norm(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_group_norm_f32(params, src0, dst);
+ ggml_compute_forward_group_norm_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_mul_mat(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
int64_t t0 = ggml_perf_time_us();
UNUSED(t0);
static void ggml_compute_forward_mul_mat_id(
const struct ggml_compute_params * params,
- const struct ggml_tensor * ids,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+ const struct ggml_tensor * ids = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
const struct ggml_tensor * src0 = dst->src[2]; // only for GGML_TENSOR_BINARY_OP_LOCALS
GGML_TENSOR_BINARY_OP_LOCALS
static void ggml_compute_forward_out_prod_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
// int64_t t0 = ggml_perf_time_us();
// UNUSED(t0);
static void ggml_compute_forward_out_prod_q_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
// int64_t t0 = ggml_perf_time_us();
// UNUSED(t0);
static void ggml_compute_forward_out_prod(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_Q4_0:
case GGML_TYPE_Q4_1:
case GGML_TYPE_IQ1_S:
case GGML_TYPE_IQ4_NL:
{
- ggml_compute_forward_out_prod_q_f32(params, src0, src1, dst);
+ ggml_compute_forward_out_prod_q_f32(params, dst);
} break;
case GGML_TYPE_F16:
{
GGML_ASSERT(false); // todo
- // ggml_compute_forward_out_prod_f16_f32(params, src0, src1, dst);
+ // ggml_compute_forward_out_prod_f16_f32(params, dst);
} break;
case GGML_TYPE_F32:
{
- ggml_compute_forward_out_prod_f32(params, src0, src1, dst);
+ ggml_compute_forward_out_prod_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_scale_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_is_contiguous(src0));
GGML_ASSERT(ggml_is_contiguous(dst));
GGML_ASSERT(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_scale(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_scale_f32(params, src0, dst);
+ ggml_compute_forward_scale_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_set_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
GGML_ASSERT(ggml_is_contiguous(dst) && ggml_is_contiguous(src0));
static void ggml_compute_forward_set(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_set_f32(params, src0, src1, dst);
+ ggml_compute_forward_set_f32(params, dst);
} break;
case GGML_TYPE_F16:
case GGML_TYPE_Q4_0:
static void ggml_compute_forward_cpy(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
- ggml_compute_forward_dup(params, src0, dst);
+ ggml_compute_forward_dup(params, dst);
}
// ggml_compute_forward_cont
static void ggml_compute_forward_cont(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
- ggml_compute_forward_dup(params, src0, dst);
+ ggml_compute_forward_dup(params, dst);
}
// ggml_compute_forward_reshape
static void ggml_compute_forward_reshape(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
// NOP
UNUSED(params);
- UNUSED(src0);
UNUSED(dst);
}
static void ggml_compute_forward_view(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0) {
+ const struct ggml_tensor * dst) {
// NOP
UNUSED(params);
- UNUSED(src0);
+ UNUSED(dst);
}
// ggml_compute_forward_permute
static void ggml_compute_forward_permute(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0) {
+ const struct ggml_tensor * dst) {
// NOP
UNUSED(params);
- UNUSED(src0);
+ UNUSED(dst);
}
// ggml_compute_forward_transpose
static void ggml_compute_forward_transpose(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0) {
+ const struct ggml_tensor * dst) {
// NOP
UNUSED(params);
- UNUSED(src0);
+ UNUSED(dst);
}
// ggml_compute_forward_get_rows
static void ggml_compute_forward_get_rows_q(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_get_rows_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_get_rows_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_get_rows(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_Q4_0:
case GGML_TYPE_Q4_1:
case GGML_TYPE_IQ1_S:
case GGML_TYPE_IQ4_NL:
{
- ggml_compute_forward_get_rows_q(params, src0, src1, dst);
+ ggml_compute_forward_get_rows_q(params, dst);
} break;
case GGML_TYPE_F16:
{
- ggml_compute_forward_get_rows_f16(params, src0, src1, dst);
+ ggml_compute_forward_get_rows_f16(params, dst);
} break;
case GGML_TYPE_F32:
case GGML_TYPE_I32:
{
- ggml_compute_forward_get_rows_f32(params, src0, src1, dst);
+ ggml_compute_forward_get_rows_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_get_rows_back_f32_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(params->ith == 0);
GGML_ASSERT(ggml_is_contiguous(dst));
static void ggml_compute_forward_get_rows_back_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(params->ith == 0);
GGML_ASSERT(ggml_is_contiguous(dst));
static void ggml_compute_forward_get_rows_back(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_get_rows_back_f32_f16(params, src0, src1, dst);
+ ggml_compute_forward_get_rows_back_f32_f16(params, dst);
} break;
case GGML_TYPE_F32:
{
- ggml_compute_forward_get_rows_back_f32(params, src0, src1, dst);
+ ggml_compute_forward_get_rows_back_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_diag_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_diag(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_diag_f32(params, src0, dst);
+ ggml_compute_forward_diag_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_diag_mask_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst,
const float value) {
+ const struct ggml_tensor * src0 = dst->src[0];
+
const int ith = params->ith;
const int nth = params->nth;
static void ggml_compute_forward_diag_mask_inf(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_diag_mask_f32(params, src0, dst, -INFINITY);
+ ggml_compute_forward_diag_mask_f32(params, dst, -INFINITY);
} break;
default:
{
static void ggml_compute_forward_diag_mask_zero(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_diag_mask_f32(params, src0, dst, 0);
+ ggml_compute_forward_diag_mask_f32(params, dst, 0);
} break;
default:
{
static void ggml_compute_forward_soft_max_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
- const struct ggml_tensor * src2,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+ const struct ggml_tensor * src2 = dst->src[2];
+
assert(ggml_is_contiguous(dst));
assert(ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_soft_max(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
- const struct ggml_tensor * src2,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_soft_max_f32(params, src0, src1, src2, dst);
+ ggml_compute_forward_soft_max_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_soft_max_back_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_is_contiguous(src0));
GGML_ASSERT(ggml_is_contiguous(src1));
GGML_ASSERT(ggml_is_contiguous(dst));
static void ggml_compute_forward_soft_max_back(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_soft_max_back_f32(params, src0, src1, dst);
+ ggml_compute_forward_soft_max_back_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_alibi_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_alibi_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_alibi(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_alibi_f16(params, src0, dst);
+ ggml_compute_forward_alibi_f16(params, dst);
} break;
case GGML_TYPE_F32:
{
- ggml_compute_forward_alibi_f32(params, src0, dst);
+ ggml_compute_forward_alibi_f32(params, dst);
} break;
case GGML_TYPE_Q4_0:
case GGML_TYPE_Q4_1:
static void ggml_compute_forward_clamp_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_clamp(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_clamp_f32(params, src0, dst);
+ ggml_compute_forward_clamp_f32(params, dst);
} break;
case GGML_TYPE_F16:
case GGML_TYPE_Q4_0:
static void ggml_compute_forward_rope_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst,
const bool forward) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_rope_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst,
const bool forward) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_rope(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_rope_f16(params, src0, src1, dst, true);
+ ggml_compute_forward_rope_f16(params, dst, true);
} break;
case GGML_TYPE_F32:
{
- ggml_compute_forward_rope_f32(params, src0, src1, dst, true);
+ ggml_compute_forward_rope_f32(params, dst, true);
} break;
default:
{
static void ggml_compute_forward_rope_back(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_rope_f16(params, src0, src1, dst, false);
+ ggml_compute_forward_rope_f16(params, dst, false);
} break;
case GGML_TYPE_F32:
{
- ggml_compute_forward_rope_f32(params, src0, src1, dst, false);
+ ggml_compute_forward_rope_f32(params, dst, false);
} break;
default:
{
static void ggml_compute_forward_conv_transpose_1d_f16_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(src0->type == GGML_TYPE_F16);
GGML_ASSERT(src1->type == GGML_TYPE_F32);
GGML_ASSERT( dst->type == GGML_TYPE_F32);
static void ggml_compute_forward_conv_transpose_1d_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(src0->type == GGML_TYPE_F32);
GGML_ASSERT(src1->type == GGML_TYPE_F32);
GGML_ASSERT( dst->type == GGML_TYPE_F32);
static void ggml_compute_forward_conv_transpose_1d(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_conv_transpose_1d_f16_f32(params, src0, src1, dst);
+ ggml_compute_forward_conv_transpose_1d_f16_f32(params, dst);
} break;
case GGML_TYPE_F32:
{
- ggml_compute_forward_conv_transpose_1d_f32(params, src0, src1, dst);
+ ggml_compute_forward_conv_transpose_1d_f32(params, dst);
} break;
default:
{
// dst: result [N, OH, OW, IC*KH*KW]
static void ggml_compute_forward_im2col_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(src0->type == GGML_TYPE_F16);
GGML_ASSERT(src1->type == GGML_TYPE_F32);
GGML_ASSERT( dst->type == GGML_TYPE_F32);
// dst: result [N, OH, OW, IC*KH*KW]
static void ggml_compute_forward_im2col_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(src0->type == GGML_TYPE_F16);
GGML_ASSERT(src1->type == GGML_TYPE_F32);
GGML_ASSERT( dst->type == GGML_TYPE_F16);
static void ggml_compute_forward_im2col(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
switch (dst->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_im2col_f16(params, src0, src1, dst);
+ ggml_compute_forward_im2col_f16(params, dst);
} break;
case GGML_TYPE_F32:
{
- ggml_compute_forward_im2col_f32(params, src0, src1, dst);
+ ggml_compute_forward_im2col_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_conv_transpose_2d(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(src0->type == GGML_TYPE_F16);
GGML_ASSERT(src1->type == GGML_TYPE_F32);
GGML_ASSERT( dst->type == GGML_TYPE_F32);
static void ggml_compute_forward_pool_1d_sk_p0(
const struct ggml_compute_params * params,
const enum ggml_op_pool op,
- const struct ggml_tensor * src,
const int k,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src = dst->src[0];
+
assert(src->type == GGML_TYPE_F32);
assert(params->ith == 0);
static void ggml_compute_forward_pool_1d(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
const int32_t * opts = (const int32_t *)dst->op_params;
GGML_ASSERT(p0 == 0); // padding not supported
GGML_ASSERT(k0 == s0); // only s = k supported
- ggml_compute_forward_pool_1d_sk_p0(params, op, src0, k0, dst);
+ ggml_compute_forward_pool_1d_sk_p0(params, op, k0, dst);
}
// ggml_compute_forward_pool_2d
static void ggml_compute_forward_pool_2d(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src = dst->src[0];
+
GGML_ASSERT(src->type == GGML_TYPE_F32);
GGML_ASSERT(params->ith == 0);
static void ggml_compute_forward_upscale_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+ const struct ggml_tensor * src0 = dst->src[0];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_upscale(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_upscale_f32(params, src0, dst);
+ ggml_compute_forward_upscale_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_pad_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+ const struct ggml_tensor * src0 = dst->src[0];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_pad(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_pad_f32(params, src0, dst);
+ ggml_compute_forward_pad_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_argsort_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+ const struct ggml_tensor * src0 = dst->src[0];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_argsort(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_argsort_f32(params, src0, dst);
+ ggml_compute_forward_argsort_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_flash_attn_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * q,
- const struct ggml_tensor * k,
- const struct ggml_tensor * v,
const bool masked,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * q = dst->src[0];
+ const struct ggml_tensor * k = dst->src[1];
+ const struct ggml_tensor * v = dst->src[2];
+
int64_t t0 = ggml_perf_time_us();
UNUSED(t0);
static void ggml_compute_forward_flash_attn_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * q,
- const struct ggml_tensor * k,
- const struct ggml_tensor * v,
const bool masked,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * q = dst->src[0];
+ const struct ggml_tensor * k = dst->src[1];
+ const struct ggml_tensor * v = dst->src[2];
+
int64_t t0 = ggml_perf_time_us();
UNUSED(t0);
static void ggml_compute_forward_flash_attn(
const struct ggml_compute_params * params,
- const struct ggml_tensor * q,
- const struct ggml_tensor * k,
- const struct ggml_tensor * v,
const bool masked,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * q = dst->src[0];
+
switch (q->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_flash_attn_f16(params, q, k, v, masked, dst);
+ ggml_compute_forward_flash_attn_f16(params, masked, dst);
} break;
case GGML_TYPE_F32:
{
- ggml_compute_forward_flash_attn_f32(params, q, k, v, masked, dst);
+ ggml_compute_forward_flash_attn_f32(params, masked, dst);
} break;
default:
{
static void ggml_compute_forward_flash_ff_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * a, // F16
- const struct ggml_tensor * b0, // F16 fc_w
- const struct ggml_tensor * b1, // F32 fc_b
- const struct ggml_tensor * c0, // F16 proj_w
- const struct ggml_tensor * c1, // F32 proj_b
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * a = dst->src[0]; // F16
+ const struct ggml_tensor * b0 = dst->src[1]; // F16 fc_w
+ const struct ggml_tensor * b1 = dst->src[2]; // F32 fc_b
+ const struct ggml_tensor * c0 = dst->src[3]; // F16 proj_w
+ const struct ggml_tensor * c1 = dst->src[4]; // F32 proj_b
+
int64_t t0 = ggml_perf_time_us();
UNUSED(t0);
static void ggml_compute_forward_flash_ff(
const struct ggml_compute_params * params,
- const struct ggml_tensor * a,
- const struct ggml_tensor * b0,
- const struct ggml_tensor * b1,
- const struct ggml_tensor * c0,
- const struct ggml_tensor * c1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * b0 = dst->src[1];
+
switch (b0->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_flash_ff_f16(params, a, b0, b1, c0, c1, dst);
+ ggml_compute_forward_flash_ff_f16(params, dst);
} break;
case GGML_TYPE_F32:
{
static void ggml_compute_forward_flash_attn_back_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * q,
- const struct ggml_tensor * k,
- const struct ggml_tensor * v,
- const struct ggml_tensor * d,
const bool masked,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * q = dst->src[0];
+ const struct ggml_tensor * k = dst->src[1];
+ const struct ggml_tensor * v = dst->src[2];
+ const struct ggml_tensor * d = dst->src[3];
+
int64_t t0 = ggml_perf_time_us();
UNUSED(t0);
static void ggml_compute_forward_flash_attn_back(
const struct ggml_compute_params * params,
- const struct ggml_tensor * q,
- const struct ggml_tensor * k,
- const struct ggml_tensor * v,
- const struct ggml_tensor * d,
const bool masked,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * q = dst->src[0];
+
switch (q->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_flash_attn_back_f32(params, q, k, v, d, masked, dst);
+ ggml_compute_forward_flash_attn_back_f32(params, masked, dst);
} break;
default:
{
static void ggml_compute_forward_win_part_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_win_part(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_win_part_f32(params, src0, dst);
+ ggml_compute_forward_win_part_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_win_unpart_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_win_unpart(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_win_unpart_f32(params, src0, dst);
+ ggml_compute_forward_win_unpart_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_unary(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
const enum ggml_unary_op op = ggml_get_unary_op(dst);
switch (op) {
case GGML_UNARY_OP_ABS:
{
- ggml_compute_forward_abs(params, src0, dst);
+ ggml_compute_forward_abs(params, dst);
} break;
case GGML_UNARY_OP_SGN:
{
- ggml_compute_forward_sgn(params, src0, dst);
+ ggml_compute_forward_sgn(params, dst);
} break;
case GGML_UNARY_OP_NEG:
{
- ggml_compute_forward_neg(params, src0, dst);
+ ggml_compute_forward_neg(params, dst);
} break;
case GGML_UNARY_OP_STEP:
{
- ggml_compute_forward_step(params, src0, dst);
+ ggml_compute_forward_step(params, dst);
} break;
case GGML_UNARY_OP_TANH:
{
- ggml_compute_forward_tanh(params, src0, dst);
+ ggml_compute_forward_tanh(params, dst);
} break;
case GGML_UNARY_OP_ELU:
{
- ggml_compute_forward_elu(params, src0, dst);
+ ggml_compute_forward_elu(params, dst);
} break;
case GGML_UNARY_OP_RELU:
{
- ggml_compute_forward_relu(params, src0, dst);
+ ggml_compute_forward_relu(params, dst);
} break;
case GGML_UNARY_OP_GELU:
{
- ggml_compute_forward_gelu(params, src0, dst);
+ ggml_compute_forward_gelu(params, dst);
} break;
case GGML_UNARY_OP_GELU_QUICK:
{
- ggml_compute_forward_gelu_quick(params, src0, dst);
+ ggml_compute_forward_gelu_quick(params, dst);
} break;
case GGML_UNARY_OP_SILU:
{
- ggml_compute_forward_silu(params, src0, dst);
+ ggml_compute_forward_silu(params, dst);
} break;
case GGML_UNARY_OP_HARDSWISH:
{
- ggml_compute_forward_hardswish(params, src0, dst);
+ ggml_compute_forward_hardswish(params, dst);
} break;
case GGML_UNARY_OP_HARDSIGMOID:
{
- ggml_compute_forward_hardsigmoid(params, src0, dst);
+ ggml_compute_forward_hardsigmoid(params, dst);
} break;
default:
{
static void ggml_compute_forward_get_rel_pos_f16(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_get_rel_pos(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F16:
{
- ggml_compute_forward_get_rel_pos_f16(params, src0, dst);
+ ggml_compute_forward_get_rel_pos_f16(params, dst);
} break;
default:
{
static void ggml_compute_forward_add_rel_pos_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
- const struct ggml_tensor * src2,
struct ggml_tensor * dst) {
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+ const struct ggml_tensor * src2 = dst->src[2];
+
const bool inplace = (bool) ((int32_t *) dst->op_params)[0];
if (!inplace && params->type == GGML_TASK_INIT) {
if (params->ith != 0) {
static void ggml_compute_forward_add_rel_pos(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
- const struct ggml_tensor * src2,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_add_rel_pos_f32(params, src0, src1, src2, dst);
+ ggml_compute_forward_add_rel_pos_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_map_unary_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst,
const ggml_unary_op_f32_t fun) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
GGML_ASSERT(ggml_are_same_shape(src0, dst));
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_map_unary(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
struct ggml_tensor * dst,
const ggml_unary_op_f32_t fun) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_map_unary_f32(params, src0, dst, fun);
+ ggml_compute_forward_map_unary_f32(params, dst, fun);
} break;
default:
{
static void ggml_compute_forward_map_binary_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst,
const ggml_binary_op_f32_t fun) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
assert(params->ith == 0);
assert(ggml_are_same_shape(src0, src1) && ggml_are_same_shape(src0, dst));
static void ggml_compute_forward_map_binary(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst,
const ggml_binary_op_f32_t fun) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_map_binary_f32(params, src0, src1, dst, fun);
+ ggml_compute_forward_map_binary_f32(params, dst, fun);
} break;
default:
{
static void ggml_compute_forward_map_custom1_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * a,
struct ggml_tensor * dst,
const ggml_custom1_op_f32_t fun) {
+
+ const struct ggml_tensor * a = dst->src[0];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_map_custom2_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * a,
- const struct ggml_tensor * b,
struct ggml_tensor * dst,
const ggml_custom2_op_f32_t fun) {
+
+ const struct ggml_tensor * a = dst->src[0];
+ const struct ggml_tensor * b = dst->src[1];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_map_custom3_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * a,
- const struct ggml_tensor * b,
- const struct ggml_tensor * c,
struct ggml_tensor * dst,
const ggml_custom3_op_f32_t fun) {
+
+ const struct ggml_tensor * a = dst->src[0];
+ const struct ggml_tensor * b = dst->src[1];
+ const struct ggml_tensor * c = dst->src[1];
+
assert(params->ith == 0);
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
static void ggml_compute_forward_map_custom1(
const struct ggml_compute_params * params,
- const struct ggml_tensor * a,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * a = dst->src[0];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_map_custom2(
const struct ggml_compute_params * params,
- const struct ggml_tensor * a,
- const struct ggml_tensor * b,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * a = dst->src[0];
+ const struct ggml_tensor * b = dst->src[1];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_map_custom3(
const struct ggml_compute_params * params,
- const struct ggml_tensor * a,
- const struct ggml_tensor * b,
- const struct ggml_tensor * c,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * a = dst->src[0];
+ const struct ggml_tensor * b = dst->src[1];
+ const struct ggml_tensor * c = dst->src[2];
+
if (params->type == GGML_TASK_INIT || params->type == GGML_TASK_FINALIZE) {
return;
}
static void ggml_compute_forward_cross_entropy_loss_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+
GGML_ASSERT(ggml_is_contiguous(src0));
GGML_ASSERT(ggml_is_contiguous(src1));
GGML_ASSERT(ggml_is_scalar(dst));
static void ggml_compute_forward_cross_entropy_loss(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_cross_entropy_loss_f32(params, src0, src1, dst);
+ ggml_compute_forward_cross_entropy_loss_f32(params, dst);
} break;
default:
{
static void ggml_compute_forward_cross_entropy_loss_back_f32(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
- const struct ggml_tensor * opt0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+ const struct ggml_tensor * src1 = dst->src[1];
+ const struct ggml_tensor * opt0 = dst->src[2];
+
GGML_ASSERT(ggml_is_contiguous(dst));
GGML_ASSERT(ggml_is_contiguous(src0));
GGML_ASSERT(ggml_is_contiguous(src1));
static void ggml_compute_forward_cross_entropy_loss_back(
const struct ggml_compute_params * params,
- const struct ggml_tensor * src0,
- const struct ggml_tensor * src1,
- const struct ggml_tensor * opt0,
struct ggml_tensor * dst) {
+
+ const struct ggml_tensor * src0 = dst->src[0];
+
switch (src0->type) {
case GGML_TYPE_F32:
{
- ggml_compute_forward_cross_entropy_loss_back_f32(params, src0, src1, opt0, dst);
+ ggml_compute_forward_cross_entropy_loss_back_f32(params, dst);
} break;
default:
{
switch (tensor->op) {
case GGML_OP_DUP:
{
- ggml_compute_forward_dup(params, tensor->src[0], tensor);
+ ggml_compute_forward_dup(params, tensor);
} break;
case GGML_OP_ADD:
{
- ggml_compute_forward_add(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_add(params, tensor);
} break;
case GGML_OP_ADD1:
{
- ggml_compute_forward_add1(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_add1(params, tensor);
} break;
case GGML_OP_ACC:
{
- ggml_compute_forward_acc(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_acc(params, tensor);
} break;
case GGML_OP_SUB:
{
- ggml_compute_forward_sub(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_sub(params, tensor);
} break;
case GGML_OP_MUL:
{
- ggml_compute_forward_mul(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_mul(params, tensor);
} break;
case GGML_OP_DIV:
{
- ggml_compute_forward_div(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_div(params, tensor);
} break;
case GGML_OP_SQR:
{
- ggml_compute_forward_sqr(params, tensor->src[0], tensor);
+ ggml_compute_forward_sqr(params, tensor);
} break;
case GGML_OP_SQRT:
{
- ggml_compute_forward_sqrt(params, tensor->src[0], tensor);
+ ggml_compute_forward_sqrt(params, tensor);
} break;
case GGML_OP_LOG:
{
- ggml_compute_forward_log(params, tensor->src[0], tensor);
+ ggml_compute_forward_log(params, tensor);
} break;
case GGML_OP_SUM:
{
- ggml_compute_forward_sum(params, tensor->src[0], tensor);
+ ggml_compute_forward_sum(params, tensor);
} break;
case GGML_OP_SUM_ROWS:
{
- ggml_compute_forward_sum_rows(params, tensor->src[0], tensor);
+ ggml_compute_forward_sum_rows(params, tensor);
} break;
case GGML_OP_MEAN:
{
- ggml_compute_forward_mean(params, tensor->src[0], tensor);
+ ggml_compute_forward_mean(params, tensor);
} break;
case GGML_OP_ARGMAX:
{
- ggml_compute_forward_argmax(params, tensor->src[0], tensor);
+ ggml_compute_forward_argmax(params, tensor);
} break;
case GGML_OP_REPEAT:
{
- ggml_compute_forward_repeat(params, tensor->src[0], tensor);
+ ggml_compute_forward_repeat(params, tensor);
} break;
case GGML_OP_REPEAT_BACK:
{
- ggml_compute_forward_repeat_back(params, tensor->src[0], tensor);
+ ggml_compute_forward_repeat_back(params, tensor);
} break;
case GGML_OP_CONCAT:
{
- ggml_compute_forward_concat(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_concat(params, tensor);
} break;
case GGML_OP_SILU_BACK:
{
- ggml_compute_forward_silu_back(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_silu_back(params, tensor);
} break;
case GGML_OP_NORM:
{
- ggml_compute_forward_norm(params, tensor->src[0], tensor);
+ ggml_compute_forward_norm(params, tensor);
} break;
case GGML_OP_RMS_NORM:
{
- ggml_compute_forward_rms_norm(params, tensor->src[0], tensor);
+ ggml_compute_forward_rms_norm(params, tensor);
} break;
case GGML_OP_RMS_NORM_BACK:
{
- ggml_compute_forward_rms_norm_back(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_rms_norm_back(params, tensor);
} break;
case GGML_OP_GROUP_NORM:
{
- ggml_compute_forward_group_norm(params, tensor->src[0], tensor);
+ ggml_compute_forward_group_norm(params, tensor);
} break;
case GGML_OP_MUL_MAT:
{
- ggml_compute_forward_mul_mat(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_mul_mat(params, tensor);
} break;
case GGML_OP_MUL_MAT_ID:
{
- ggml_compute_forward_mul_mat_id(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_mul_mat_id(params, tensor);
} break;
case GGML_OP_OUT_PROD:
{
- ggml_compute_forward_out_prod(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_out_prod(params, tensor);
} break;
case GGML_OP_SCALE:
{
- ggml_compute_forward_scale(params, tensor->src[0], tensor);
+ ggml_compute_forward_scale(params, tensor);
} break;
case GGML_OP_SET:
{
- ggml_compute_forward_set(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_set(params, tensor);
} break;
case GGML_OP_CPY:
{
- ggml_compute_forward_cpy(params, tensor->src[0], tensor);
+ ggml_compute_forward_cpy(params, tensor);
} break;
case GGML_OP_CONT:
{
- ggml_compute_forward_cont(params, tensor->src[0], tensor);
+ ggml_compute_forward_cont(params, tensor);
} break;
case GGML_OP_RESHAPE:
{
- ggml_compute_forward_reshape(params, tensor->src[0], tensor);
+ ggml_compute_forward_reshape(params, tensor);
} break;
case GGML_OP_VIEW:
{
- ggml_compute_forward_view(params, tensor->src[0]);
+ ggml_compute_forward_view(params, tensor);
} break;
case GGML_OP_PERMUTE:
{
- ggml_compute_forward_permute(params, tensor->src[0]);
+ ggml_compute_forward_permute(params, tensor);
} break;
case GGML_OP_TRANSPOSE:
{
- ggml_compute_forward_transpose(params, tensor->src[0]);
+ ggml_compute_forward_transpose(params, tensor);
} break;
case GGML_OP_GET_ROWS:
{
- ggml_compute_forward_get_rows(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_get_rows(params, tensor);
} break;
case GGML_OP_GET_ROWS_BACK:
{
- ggml_compute_forward_get_rows_back(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_get_rows_back(params, tensor);
} break;
case GGML_OP_DIAG:
{
- ggml_compute_forward_diag(params, tensor->src[0], tensor);
+ ggml_compute_forward_diag(params, tensor);
} break;
case GGML_OP_DIAG_MASK_INF:
{
- ggml_compute_forward_diag_mask_inf(params, tensor->src[0], tensor);
+ ggml_compute_forward_diag_mask_inf(params, tensor);
} break;
case GGML_OP_DIAG_MASK_ZERO:
{
- ggml_compute_forward_diag_mask_zero(params, tensor->src[0], tensor);
+ ggml_compute_forward_diag_mask_zero(params, tensor);
} break;
case GGML_OP_SOFT_MAX:
{
- ggml_compute_forward_soft_max(params, tensor->src[0], tensor->src[1], tensor->src[2], tensor);
+ ggml_compute_forward_soft_max(params, tensor);
} break;
case GGML_OP_SOFT_MAX_BACK:
{
- ggml_compute_forward_soft_max_back(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_soft_max_back(params, tensor);
} break;
case GGML_OP_ROPE:
{
- ggml_compute_forward_rope(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_rope(params, tensor);
} break;
case GGML_OP_ROPE_BACK:
{
- ggml_compute_forward_rope_back(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_rope_back(params, tensor);
} break;
case GGML_OP_ALIBI:
{
- ggml_compute_forward_alibi(params, tensor->src[0], tensor);
+ ggml_compute_forward_alibi(params, tensor);
} break;
case GGML_OP_CLAMP:
{
- ggml_compute_forward_clamp(params, tensor->src[0], tensor);
+ ggml_compute_forward_clamp(params, tensor);
} break;
case GGML_OP_CONV_TRANSPOSE_1D:
{
- ggml_compute_forward_conv_transpose_1d(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_conv_transpose_1d(params, tensor);
} break;
case GGML_OP_IM2COL:
{
- ggml_compute_forward_im2col(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_im2col(params, tensor);
} break;
case GGML_OP_CONV_TRANSPOSE_2D:
{
- ggml_compute_forward_conv_transpose_2d(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_conv_transpose_2d(params, tensor);
} break;
case GGML_OP_POOL_1D:
{
- ggml_compute_forward_pool_1d(params, tensor->src[0], tensor);
+ ggml_compute_forward_pool_1d(params, tensor);
} break;
case GGML_OP_POOL_2D:
{
- ggml_compute_forward_pool_2d(params, tensor->src[0], tensor);
+ ggml_compute_forward_pool_2d(params, tensor);
} break;
case GGML_OP_UPSCALE:
{
- ggml_compute_forward_upscale(params, tensor->src[0], tensor);
+ ggml_compute_forward_upscale(params, tensor);
} break;
case GGML_OP_PAD:
{
- ggml_compute_forward_pad(params, tensor->src[0], tensor);
+ ggml_compute_forward_pad(params, tensor);
} break;
case GGML_OP_ARGSORT:
{
- ggml_compute_forward_argsort(params, tensor->src[0], tensor);
+ ggml_compute_forward_argsort(params, tensor);
} break;
case GGML_OP_LEAKY_RELU:
{
- ggml_compute_forward_leaky_relu(params, tensor->src[0], tensor);
+ ggml_compute_forward_leaky_relu(params, tensor);
} break;
case GGML_OP_FLASH_ATTN:
{
const int32_t t = ggml_get_op_params_i32(tensor, 0);
GGML_ASSERT(t == 0 || t == 1);
const bool masked = t != 0;
- ggml_compute_forward_flash_attn(params, tensor->src[0], tensor->src[1], tensor->src[2], masked, tensor);
+ ggml_compute_forward_flash_attn(params, masked, tensor);
} break;
case GGML_OP_FLASH_FF:
{
- ggml_compute_forward_flash_ff(params, tensor->src[0], tensor->src[1], tensor->src[2], tensor->src[3], tensor->src[4], tensor);
+ ggml_compute_forward_flash_ff(params, tensor);
} break;
case GGML_OP_FLASH_ATTN_BACK:
{
int32_t t = ggml_get_op_params_i32(tensor, 0);
GGML_ASSERT(t == 0 || t == 1);
bool masked = t != 0;
- ggml_compute_forward_flash_attn_back(params, tensor->src[0], tensor->src[1], tensor->src[2], tensor->src[3], masked, tensor);
+ ggml_compute_forward_flash_attn_back(params, masked, tensor);
} break;
case GGML_OP_WIN_PART:
{
- ggml_compute_forward_win_part(params, tensor->src[0], tensor);
+ ggml_compute_forward_win_part(params, tensor);
} break;
case GGML_OP_WIN_UNPART:
{
- ggml_compute_forward_win_unpart(params, tensor->src[0], tensor);
+ ggml_compute_forward_win_unpart(params, tensor);
} break;
case GGML_OP_UNARY:
{
- ggml_compute_forward_unary(params, tensor->src[0], tensor);
+ ggml_compute_forward_unary(params, tensor);
} break;
case GGML_OP_GET_REL_POS:
{
- ggml_compute_forward_get_rel_pos(params, tensor->src[0], tensor);
+ ggml_compute_forward_get_rel_pos(params, tensor);
} break;
case GGML_OP_ADD_REL_POS:
{
- ggml_compute_forward_add_rel_pos(params, tensor->src[0], tensor->src[1], tensor->src[2], tensor);
+ ggml_compute_forward_add_rel_pos(params, tensor);
} break;
case GGML_OP_MAP_UNARY:
{
ggml_unary_op_f32_t fun;
memcpy(&fun, tensor->op_params, sizeof(fun));
- ggml_compute_forward_map_unary(params, tensor->src[0], tensor, fun);
+ ggml_compute_forward_map_unary(params, tensor, fun);
}
break;
case GGML_OP_MAP_BINARY:
{
ggml_binary_op_f32_t fun;
memcpy(&fun, tensor->op_params, sizeof(fun));
- ggml_compute_forward_map_binary(params, tensor->src[0], tensor->src[1], tensor, fun);
+ ggml_compute_forward_map_binary(params, tensor, fun);
}
break;
case GGML_OP_MAP_CUSTOM1_F32:
{
ggml_custom1_op_f32_t fun;
memcpy(&fun, tensor->op_params, sizeof(fun));
- ggml_compute_forward_map_custom1_f32(params, tensor->src[0], tensor, fun);
+ ggml_compute_forward_map_custom1_f32(params, tensor, fun);
}
break;
case GGML_OP_MAP_CUSTOM2_F32:
{
ggml_custom2_op_f32_t fun;
memcpy(&fun, tensor->op_params, sizeof(fun));
- ggml_compute_forward_map_custom2_f32(params, tensor->src[0], tensor->src[1], tensor, fun);
+ ggml_compute_forward_map_custom2_f32(params, tensor, fun);
}
break;
case GGML_OP_MAP_CUSTOM3_F32:
{
ggml_custom3_op_f32_t fun;
memcpy(&fun, tensor->op_params, sizeof(fun));
- ggml_compute_forward_map_custom3_f32(params, tensor->src[0], tensor->src[1], tensor->src[2], tensor, fun);
+ ggml_compute_forward_map_custom3_f32(params, tensor, fun);
}
break;
case GGML_OP_MAP_CUSTOM1:
{
- ggml_compute_forward_map_custom1(params, tensor->src[0], tensor);
+ ggml_compute_forward_map_custom1(params, tensor);
}
break;
case GGML_OP_MAP_CUSTOM2:
{
- ggml_compute_forward_map_custom2(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_map_custom2(params, tensor);
}
break;
case GGML_OP_MAP_CUSTOM3:
{
- ggml_compute_forward_map_custom3(params, tensor->src[0], tensor->src[1], tensor->src[2], tensor);
+ ggml_compute_forward_map_custom3(params, tensor);
}
break;
case GGML_OP_CROSS_ENTROPY_LOSS:
{
- ggml_compute_forward_cross_entropy_loss(params, tensor->src[0], tensor->src[1], tensor);
+ ggml_compute_forward_cross_entropy_loss(params, tensor);
}
break;
case GGML_OP_CROSS_ENTROPY_LOSS_BACK:
{
- ggml_compute_forward_cross_entropy_loss_back(params, tensor->src[0], tensor->src[1], tensor->src[2], tensor);
+ ggml_compute_forward_cross_entropy_loss_back(params, tensor);
}
break;
case GGML_OP_NONE:
overview / pkg / ggml / sources / llama.cpp / commitdiff