Skip to content

/github/workspace/src/MatrixFunctions/mat_mult_trans/kernels/plp_mat_mult_trans_i16p_xpulpv2.c

Functions

Name
void plp_mat_mult_trans_i16p_xpulpv2(void * args)
Parallel matrix transposed matrix multiplication of a 16-bit integer matrices for XPULPV2 extension.

Defines

Name
BASIC_VERSION

Functions Documentation

function plp_mat_mult_trans_i16p_xpulpv2

void plp_mat_mult_trans_i16p_xpulpv2(
    void * args
)

Parallel matrix transposed matrix multiplication of a 16-bit integer matrices for XPULPV2 extension.

Parameters:

Return: none

Par: Exploiting SIMD instructions

The 16 bit values are packed two each into 32 bit vectors and then the two dot products are performed on 32 bit vectors, with 32 bit accumulator.

Macros Documentation

define BASIC_VERSION

#define BASIC_VERSION

Source code

/* =====================================================================
 * Project:      PULP DSP Library
 * Title:        plp_mat_mult_i16p_xpulpv2.c
 * Description:  parallel 16-bit integer matrix multiplication for XPULPV2
 *
 * $Date:        22. December 2019
 * $Revision:    V0
 *
 * Target Processor: PULP cores
 * ===================================================================== */
/*
 * Copyright (C) 2019 ETH Zurich and University of Bologna.
 *
 * Author: Tom Kuchler, ETH Zurich
 *
 * SPDX-License-Identifier: Apache-2.0
 *
 * Licensed under the Apache License, Version 2.0 (the License); you may
 * not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include "plp_math.h"

void plp_mat_mult_trans_i16p_xpulpv2(void *args) {

    int core_id = hal_core_id();

    plp_mat_mult_instance_i16 *arguments = (plp_mat_mult_instance_i16 *)args;
    const int16_t *__restrict__ pSrcA = arguments->pSrcA;
    const int16_t *__restrict__ pSrcB = arguments->pSrcB;
    uint32_t M = arguments->M;
    uint32_t N = arguments->N;
    uint32_t O = arguments->O;
    uint32_t nPE = arguments->nPE;
    int32_t *__restrict__ pDstC = arguments->pDstC;

#define BASIC_VERSION // if used don't forget to also use the undefine at end of file
#ifdef BASIC_VERSION

    uint32_t m; // loop counter for M
    uint32_t n; // loop counter for N
    uint32_t o; // loop counter for O

    for (m = core_id; m < M; m += nPE) {
        for (o = 0; o < O; o++) {
            int32_t sum = 0;
            for (n = 0; n < N; n++) {
                sum = sum + pSrcA[m * N + n] * pSrcB[o * N + n];
            }
            pDstC[m * O + o] = sum;
        }
    }

    hal_team_barrier();

#else

    // TODO hackathon

#endif
#undef BASIC_VERSION
}

Updated on 2023-03-01 at 16:16:33 +0000