MSP430FR5994: Using LEA for matrix multiplications

Hi Siddhant,

Sorry for reply you later.

You would like to calcul a [256,20] matrix?  

This size should less than 8K, I think this should can work normally.

And attach LEA code example(register level), maybe useful for you.

LEACMD__MPYMATRIX.zip

Thanks!

Best Regards

Johnson

Thank you. I will have a look at the code and then update the thread at the earliest!

In the example attached, I am trying to run a very basic example as follows - 

#include "msp430fr5994.h"

#include "lea_params.h"
#include "reference/reference_c.h"

#include <math.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

// Convert MSP430 address to internal LEA address mapping.
#define LEA_CONVERT_ADDRESS(x)    ((uint16_t)(((uintptr_t)(x) >> 2) & 0xffff))

// Convert LEA address to MSP430 address mapping.
#define LEA_REVERT_ADDRESS(x)     ((uintptr_t)(((uint32_t)(x) << 2)))

// Test Size
#define VECTOR_SIZE       2

// Q15 format -> 0.5 -> 0.5*2^15 = 32768
const int16_t initInputA[VECTOR_SIZE][VECTOR_SIZE] = {{559, 393},
                                                      {444, 980}};
const int16_t initInputB[VECTOR_SIZE][VECTOR_SIZE] = {{1,0},
                                                      {1,0}};

#pragma DATA_SECTION(inputA, ".leaRAM");
#pragma DATA_ALIGN(inputA, 4);
int16_t inputA[VECTOR_SIZE][VECTOR_SIZE];

#pragma DATA_SECTION(inputB, ".leaRAM");
#pragma DATA_ALIGN(inputB, 4);
int16_t inputB[VECTOR_SIZE][VECTOR_SIZE];

#pragma DATA_SECTION(output, ".leaRAM");
#pragma DATA_ALIGN(output, 4);
int16_t output[VECTOR_SIZE][VECTOR_SIZE];

#pragma DATA_SECTION(params, ".leaRAM");
#pragma DATA_ALIGN(params, 4);
LEA_raddmlParams params;

int16_t outputGolden[VECTOR_SIZE][VECTOR_SIZE];

volatile bool success = false;
volatile uint16_t benchmark;

void main(void)
{

    WDTCTL = WDTPW | WDTHOLD;       // Stop watchdog timer
    PM5CTL0 &= ~LOCKLPM5;           // Clear lock bit

    CSCTL0_H = CSKEY_H;
    CSCTL3 = 0;
    CSCTL0_H = 0;

    /* Initialize LEASC. */
    LEACNF0 = LEALPR | LEAILPM;
    LEASCCNF1 = 0;
    LEASCCNF2 = 0;
    LEASCCNF2 |= LEASCMT >> 2;
    LEASCPMS1 = 0;
    LEASCPMS0 = 0;
    LEASCPMDST = 0;
    LEASCPMCTL |= LEASCCMDEN;  // Enable LEA by setting command enable
    LEASCIFG = LEASCPMCMDIFG | LEASCSDIIFG | LEASCOORIFG | LEASCCOVLIFG; // Clear all interrupt flags
    LEASCIE |= LEASCPMCMDIE; // Enable the command complete interrupt

    /* Load input data */
    memcpy(inputA,initInputA,sizeof(initInputA));
    memcpy(inputB,initInputB,sizeof(initInputB));

    /* Set parameters */
    params.vectorSize = VECTOR_SIZE;
    params.input2 = LEA_CONVERT_ADDRESS(inputB);
    params.output = LEA_CONVERT_ADDRESS(output);
    params.input1Offset = 1;
    params.input2Offset = 1;
    params.outputOffset = 1;

    /* Load source arguments to LEA. */
    LEASCPMS0 = LEA_CONVERT_ADDRESS(inputA);
    LEASCPMS1 = LEA_CONVERT_ADDRESS(&params);

    /* Invoke RAM command with interrupts. */
    LEAPMCB = LEACMD__MPYMATRIX | LEAITFLG1;

    /* Enable Interrupt & enter LPM0 mode. */
    __bis_SR_register(GIE + LPM0_bits);

    /* BREAK HERE, RAM version */
    __no_operation();

    while(1);
}

Now, here instead of obtaining {{559,0}, {444,0}} as the output - I received only [[0,0],[0,0]]. This is also the same in case I treat the 2x2 matrix as an array of 4 elements or a 1x4 matrix like the one given in the sample. As far as  I can understand, this must be due to right shifting of the result 15 times. And, this is exactly where I had a problem, where I need the original values for my calculations and not the shifted result. Is it possible to obtain the answer in the original form - in this case it would be  - {{559,0}, {444,0}} ? Let me know if any more information is necessary. Thank you