Matrix vhdl中矩阵乘法的警告_Matrix_Vhdl_Multiplication

Matrix vhdl中矩阵乘法的警告

matrix vhdl

Matrix vhdl中矩阵乘法的警告,matrix,vhdl,multiplication,Matrix,Vhdl,Multiplication,因此，我开始为一个简单的4x4矩阵乘法编写代码。代码在这一点上是非常粗糙的，我将尝试在最后修改它，但我只是想看看它是否有效。它使用8位输入对矩阵的2位元素进行直接赋值。类似地，4个输出是通过连接结果矩阵每行的4个元素创建的。下面您可以看到代码我遇到的问题是，在我运行代码之后，我得到大约100个这种类型的警告算术操作数中有一个“U”|“X”|“W”|“Z”|“-”，结果将是“X”（es）我做错了什么？变量a、B、temp或其他变量的初始化是否有问题 LIBRARY IEEE; USE IE

因此，我开始为一个简单的4x4矩阵乘法编写代码。代码在这一点上是非常粗糙的，我将尝试在最后修改它，但我只是想看看它是否有效。它使用8位输入对矩阵的2位元素进行直接赋值。类似地，4个输出是通过连接结果矩阵每行的4个元素创建的。下面您可以看到代码

我遇到的问题是，在我运行代码之后，我得到大约100个这种类型的警告算术操作数中有一个“U”|“X”|“W”|“Z”|“-”，结果将是“X”（es）我做错了什么？变量a、B、temp或其他变量的初始化是否有问题

LIBRARY IEEE;
USE IEEE.STD_LOGIC_1164.ALL;
USE IEEE.std_logic_unsigned.all;

ENTITY matrix_mul IS
    PORT( 
    a1: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    a2: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    a3: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    a4: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    b1: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    b2: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    b3: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    b4: IN STD_LOGIC_VECTOR(7 DOWNTO 0);
    x1: OUT STD_LOGIC_VECTOR(15 DOWNTO 0);
    x2: OUT STD_LOGIC_VECTOR(15 DOWNTO 0);
    x3: OUT STD_LOGIC_VECTOR(15 DOWNTO 0);
    x4: OUT STD_LOGIC_VECTOR(15 DOWNTO 0)
    );
END matrix_mul;

ARCHITECTURE arch OF matrix_mul IS

TYPE array_2b_1x4 IS ARRAY (3 DOWNTO 0) of STD_LOGIC_VECTOR(1 DOWNTO 0);
TYPE matrix_2b_4x4 IS ARRAY (3 DOWNTO 0) of array_2b_1x4;
TYPE array_4b_1x4 IS ARRAY (3 DOWNTO 0) of STD_LOGIC_VECTOR(3 DOWNTO 0);
TYPE matrix_4b_4x4 IS ARRAY (3 DOWNTO 0) of array_4b_1x4;


BEGIN
    PROCESS (a1,a2,a3,a4,b1,b2,b3,b4)
    VARIABLE A : matrix_2b_4x4 := (others => (others => (others => '0')));
    VARIABLE B : matrix_2b_4x4 := (others => (others => (others => '0')));
    VARIABLE temp : matrix_4b_4x4 := (others => (others => (others => '0')));

    BEGIN
        A(0)(0) := a1(7 DOWNTO 6);
        A(0)(1) := a1(5 DOWNTO 4);
        A(0)(2) := a1(3 DOWNTO 2);
        A(0)(3) := a1(1 DOWNTO 0);
        A(1)(0) := a2(7 DOWNTO 6);
        A(1)(1) := a2(5 DOWNTO 4);
        A(1)(2) := a2(3 DOWNTO 2);
        A(1)(3) := a2(1 DOWNTO 0);
        A(2)(0) := a3(7 DOWNTO 6);
        A(2)(1) := a3(5 DOWNTO 4);
        A(2)(2) := a3(3 DOWNTO 2);
        A(2)(3) := a3(1 DOWNTO 0);
        A(3)(0) := a4(7 DOWNTO 6);
        A(3)(1) := a4(5 DOWNTO 4);
        A(3)(2) := a4(3 DOWNTO 2);
        A(3)(3) := a4(1 DOWNTO 0);
        B(0)(0) := b1(7 DOWNTO 6);
        B(0)(1) := b1(5 DOWNTO 4);
        B(0)(2) := b1(3 DOWNTO 2);
        B(0)(3) := b1(1 DOWNTO 0);
        B(1)(0) := b2(7 DOWNTO 6);
        B(1)(1) := b2(5 DOWNTO 4);
        B(1)(2) := b2(3 DOWNTO 2);
        B(1)(3) := b2(1 DOWNTO 0);
        B(2)(0) := b3(7 DOWNTO 6);
        B(2)(1) := b3(5 DOWNTO 4);
        B(2)(2) := b3(3 DOWNTO 2);
        B(2)(3) := b3(1 DOWNTO 0);
        B(3)(0) := b4(7 DOWNTO 6);
        B(3)(1) := b4(5 DOWNTO 4);
        B(3)(2) := b4(3 DOWNTO 2);
        B(3)(3) := b4(1 DOWNTO 0);


        FOR i IN 0 TO 3 LOOP
            FOR j IN 0 TO 3 LOOP
                FOR k IN 0 TO 3 LOOP
                    temp(i)(j) := temp(i)(j) + ( A(i)(k) * B(k)(j) );
                END LOOP;
            END LOOP;
        END LOOP;

        x1 <= temp(0)(0) & temp(0)(1) & temp(0)(2) & temp(0)(3);
        x2 <= temp(1)(0) & temp(1)(1) & temp(1)(2) & temp(1)(3);
        x3 <= temp(2)(0) & temp(2)(1) & temp(2)(2) & temp(2)(3);
        x4 <= temp(3)(0) & temp(3)(1) & temp(3)(2) & temp(3)(3);

    END PROCESS;
END arch;

IEEE库；
使用IEEE.STD_LOGIC_1164.ALL；
使用IEEE.std_logic_unsigned.all；
实体矩阵是
港口（
a1：标准逻辑向量（7到0）；
a2：标准逻辑向量（7到0）；
a3：标准逻辑向量（7到0）；
a4：标准逻辑向量（7到0）；
b1：标准逻辑向量（7到0）；
b2：标准逻辑向量（7到0）；
b3：标准逻辑向量（7到0）；
b4：标准逻辑向量（7到0）；
x1：输出标准逻辑向量（15到0）；
x2：输出标准逻辑向量（15到0）；
x3：输出标准逻辑向量（15到0）；
x4：输出标准逻辑向量（15到0）
);
末端矩阵；
matrix_mul的体系结构
类型数组_2b_1x4是标准逻辑_向量（1向下到0）的数组（3向下到0）；
类型矩阵_2b_4x4是数组_2b_1x4的数组（3到0）；
类型数组_4b_1x4是标准逻辑向量（3向下到0）的数组（3向下到0）；
类型矩阵_4b_4x4是数组_4b_1x4的数组（3到0）；
开始
工艺（a1、a2、a3、a4、b1、b2、b3、b4）
变量A：矩阵_2b_4x4:=（其他=>（其他=>（其他=>“0”）；
变量B：矩阵_2b_4x4:=（其他=>（其他=>（其他=>“0”）；
变量温度：矩阵_4b_4x4:=（其他=>（其他=>（其他=>“0”）；
开始
A（0）（0）：=a1（7至6）；
A（0）（1）：=a1（5到4）；
A（0）（2）：=a1（3到2）；
A（0）（3）：=a1（1到0）；
A（1）（0）：=a2（7至6）；
A（1）（1）：=a2（5至4）；
A（1）（2）：=a2（3至2）；
A（1）（3）：=a2（1到0）；
A(2)(0):=a3(7至6);；
A(2)(1):=a3(5至4);；
A(2):=a3(3至2);；
A(2)(3):=a3(1至0);；
A（3）（0）：=a4（7至6）；
A（3）（1）：=a4（5至4）；
A（3）（2）：=a4（3至2）；
A（3）（3）：=a4（1至0）；
B(0):=b1(7至6);；
B（0）（1）：=b1（5到4）；
B（0）（2）：=b1（3到2）；
B（0）（3）：=b1（1到0）；
B（1）（0）：=b2（7至6）；
B（1）（1）：=b2（5至4）；
B（1）（2）：=b2（3至2）；
B（1）（3）：=b2（1到0）；
B（2）（0）：=b3（7到6）；
B（2）（1）：=b3（5到4）；
B（2）（2）：=b3（3到2）；
B（2）（3）：=b3（1到0）；
B（3）（0）：=b4（7至6）；
B（3）（1）：=b4（5至4）；
B（3）（2）：=b4（3至2）；
B（3）（3）：=b4（1到0）；
对于0到3循环中的i
对于0到3循环中的j
对于0到3循环中的k
温度（i）（j）：=温度（i）（j）+（A（i）（k）*B（k）（j））；
端环；
端环；
端环；
x1问题在于这些初始化在进程内的变量声明中进行
VARIABLE A : matrix_2b_4x4 := (others => (others => (others => '0')));
VARIABLE B : matrix_2b_4x4 := (others => (others => (others => '0')));
VARIABLE temp : matrix_4b_4x4 := (others => (others => (others => '0')));

当流程ia第一次执行时，仅发生一次
您还没有发布您的测试台，但我怀疑a
和b
没有在那里的声明中初始化。因此，当流程第一次执行时，它们都是'U'
。因此，temp
被分配一些/所有'X'
es。在您为测试台中的a
和b
分配了一些有效值后，该过程将再次执行，但temp
仍然分配了从开始时的最后一次运行开始的值，并且包含'X'
es，并将它们保留在加法中
这不是你想要的矩阵乘法。您已经描述了一个组合过程，因此，您必须为每次运行初始化过程中的所有变量。通过这种方式，它不依赖于上一次运行，因此，累加从temp
=零开始。在此过程中，您已经正确分配了a
和B
，但缺少temp
。只需在for
循环之前初始化它：
...
temp := (others => (others => (others => '0')));
FOR i IN 0 TO 3 LOOP
...

进行此更改后，您可以在变量声明中删除变量初始化。
问题在于这些初始化在流程中的变量声明中进行
VARIABLE A : matrix_2b_4x4 := (others => (others => (others => '0')));
VARIABLE B : matrix_2b_4x4 := (others => (others => (others => '0')));
VARIABLE temp : matrix_4b_4x4 := (others => (others => (others => '0')));

当流程ia第一次执行时，仅发生一次
您还没有发布您的测试台，但我怀疑a
和b
没有在那里的声明中初始化。因此，当流程第一次执行时，它们都是'U'
。因此，temp
被分配一些/所有'X'
es。在您为测试台中的a
和b
分配了一些有效值后，该过程将再次执行，但temp
仍然分配了从开始时的最后一次运行开始的值，并且包含'X'
es，并将它们保留在加法中
这不是你想要的矩阵乘法。您已经描述了一个组合过程，因此，您必须为每次运行初始化过程中的所有变量。通过这种方式，它不依赖于上一次运行，因此，累加从temp
=零开始。在此过程中，您已经正确分配了a
和B
，但缺少temp
。只需在for
循环之前初始化它：
...
temp := (others => (others => (others => '0')));
FOR i IN 0 TO 3 LOOP
...

做了这个改变之后，y