计算机组成原理_2_ALU

最新推荐文章于 2023-10-02 21:22:59 发布
最新推荐文章于 2023-10-02 21:22:59 发布
阅读量721 收藏 1
点赞数
文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60201851/article/details/128223059
版权

ALU:逻辑算术单元

1 实验要求

在ALU类中实现2个方法，具体如下

1.计算两个32位二进制整数补码真值的和

 public DataType add(DataType src, DataType dest)

2.计算两个32位二进制整数补码真值的差，dest表示被减数，src表示减数(即计算dest - src)

 public DataType sub(DataType src, DataType dest)

3.在ALU类中实现实现整数的二进制乘法(要求使用布斯乘法实现)。
输入和输出均为32位二进制补码，计算结果直接截取低32位作为最终输出

 public DataType mul(DataType src, DataType dest)

2 实验攻略

2.1 代码实现要求

有些同学可能注意到，将传入的参数通过transformer转化为int，再通过整数的加减运算后，将结果重新转化为DataType即可轻松完成实验。在此，我们明确禁止各位采用这种方法来完成本次实验。

2.2 数据封装

从本次实验开始，我们采用统一的类DataType来封装32位的二进制数，包括二进制补码整数、NBCD码与IEEE754浮点数。核心数据结构如下

package util;

import java.util.Collections;

public class DataType {

    private final byte[] data = new byte[4];
// 下面代码不需要考虑，只需要知道是32位2进制数的一个包装类即可
    public DataType(String dataStr) {
        // 目前是大端实现，高位字节存放在低地址
        int length = dataStr.length();
        if (length == 8 || length == 16 || length == 32) {
            dataStr = String.join("", Collections.nCopies(32 - length, "0")) + dataStr;
            for (int i = 0; i < 32; i++) {
                char temp = dataStr.charAt(i);
                if (temp == '0' || temp == '1') {
                    data[i / 8] |= ((dataStr.charAt(i) - '0') << (7 - i % 8));
                } else {
                    throw new NumberFormatException("Illegal dataStr: " + dataStr);
                }
            }
        } else {
            throw new NumberFormatException("Illegal dataStr: " + dataStr);
        }
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < 4; i++) {
            stringBuilder.append(Transformer.intToBinary(String.valueOf(data[i])).substring(24));
        }
        return stringBuilder.toString();
    }

}

采用这样的数据封装将保证DataType类中存放的一定是32位二进制数，并且有利于ALU等运算模块与其他模块的整合。为了方便编码，我们为DataType类提供了构造函数与toString函数，便于DataType对象与String对象之间的转化，具体可阅读DataType类源码。

3实现

3.0 取反加一操作

加一操作，额外使用jinWei 来代表加1 操作，再通过四个if-else 使得逻辑非常的清晰

    public static String reverse(String str) {
        char[] ansArr = new char[str.length()];
        for (int i = 0; i < ansArr.length; i++) {
            ansArr[i] = str.charAt(i) == '0' ? '1' : '0';
        }
        return new String(ansArr);
    }

    public static String oneAdder(String str) {
        char[] ansArr = new char[str.length()];
        int jinWei = 1;
        for (int i = 31; i >= 0; i--) {
            if (str.charAt(i) == '0' && jinWei == 1) {
                ansArr[i] = '1';
                jinWei = 0;
            } else if (str.charAt(i) == '0' && jinWei == 0) {
                ansArr[i] = '0';
            } else if (str.charAt(i) == '1' && jinWei == 1) {
                ansArr[i] = '0';
            } else if (str.charAt(i) == '1' && jinWei == 0) {
                ansArr[i] = '1';
            }
        }
        return new String(ansArr);
    }

3.1 32位补码加法

3.1.1 代码实现

对于加法操作，可以直接进行x+y+jinWei 的操作，而不需要分正负号

    /**
     * 返回两个二进制整数的和
     * dest + src
     *
     * @param src  32-bits
     * @param dest 32-bits
     * @return 32-bits
     */
    public DataType add(DataType src, DataType dest) {
        char[] ansArr = new char[32];
        Arrays.fill(ansArr, '0');
        char[] srcArr = src.toString().toCharArray();
        char[] destArr = dest.toString().toCharArray();
        boolean jinWei = false;
        String ans;
        for (int i = 31; i >= 0; i--) {
            if (srcArr[i] == '0' && destArr[i] == '0') {
                ansArr[i] = jinWei ? '1' : '0';
                jinWei = false;
            } else if (srcArr[i] == '1' && destArr[i] == '1') {
                ansArr[i] = jinWei ? '1' : '0';
                jinWei = true;
            } else {
                ansArr[i] = jinWei ? '0' : '1';
//                    jinWei状态不变
            }
        }
        ans = new String(ansArr);
        return new DataType(ans);
        /**
         * 加法直接进行加减，不需要管正负号
         */
    }
3.1.2 测试用例
package cpu.alu;

import org.junit.Test;
import util.DataType;
import util.Transformer;

import java.util.Random;

import static org.junit.Assert.assertEquals;

public class ALUAddTest {

    private final ALU alu = new ALU();
    private DataType src;
    private DataType dest;
    private DataType result;

    @Test
    public void AddTest1() {
        src = new DataType("10000000000000000000000000000000");
        dest = new DataType("00000000000000000000000000000100");
        result = alu.add(src, dest);
        assertEquals("00000000000000000000000000001000", result.toString());
    }

    @Test
    public void AddTest2() {
        src = new DataType("10000000000000000000000000000000");
        dest = new DataType("00000000000000000000000000000100");
        result = alu.add(src, dest);
        assertEquals("00000000000000000000000000001000", result.toString());
    }

    @Test
    public void mulTest() {
        for (int i = 0; i < 100000; i++) {
            Random random = new Random();
            int x = random.nextInt(999999999);
            int y = random.nextInt(999999999);
            src = new DataType(Transformer.intToBinary(String.valueOf(x)));
            dest = new DataType(Transformer.intToBinary(String.valueOf(y)));
            result = alu.add(src, dest);
            assertEquals(Transformer.intToBinary(String.valueOf(x + y)), result.toString());
        }
    }
}

3.2 32位补码减法

3.2.1 代码实现
  • 对于减法，只需要将被减数取反加1即可，这样子就能够得到对应的相反数的补码，从而实现由减法变为加法。
  • 在x86中，减法是dest-src
    /**
     * 返回两个二进制整数的差
     * dest - src
     */
    public DataType sub(DataType src, DataType dest) {
        /**
         * 减法直接把src取反加1即可，变为加法
         */
        return add(dest, new DataType(oneAdder(reverse(src.toString()))));
    }
3.2.2 测试用例
package cpu.alu;

import org.junit.Test;
import util.DataType;
import util.Transformer;

import static org.junit.Assert.assertEquals;

public class ALUSubTest {

    private final ALU alu = new ALU();
    private DataType src;
    private DataType dest;
    private DataType result;

    @Test
    public void SubTest0() {
        src = new DataType("00000000000000000000000000000001");   //2147483647
        dest = new DataType("10000000000000000000000000000001"); // -1
        result = alu.sub(src, dest); // -2147483648
        assertEquals("10000000000000000000000000000000", result.toString());
    }

    @Test
    public void SubTest1() {
        src = new DataType("01111111111111111111111111111111");   //2147483647
        dest = new DataType("11111111111111111111111111111111"); // -1
        result = alu.sub(src, dest);
        assertEquals("10000000000000000000000000000000", result.toString());
    }

    @Test
    public void SubTest2() {
        src = new DataType("11111111111111111111111111111000"); // -7
        dest = new DataType("00000000000000000000000000000111"); // 7
        result = alu.sub(dest, src); //-14
        assertEquals("11111111111111111111111111110001", result.toString());
    }

    @Test
    public void SubTest3() {
        src = new DataType("00000000000000000000000000000000");
        dest = new DataType("10000000000000000000000000000000");
        result = alu.sub(dest, src);
        assertEquals("10000000000000000000000000000000", result.toString());
    }

    @Test
    public void SubTest4() {
        src = new DataType("00000000000000000000000000000000");
        dest = new DataType("10000000000000000000000000000001");
        result = alu.sub(dest, src);
        assertEquals("01111111111111111111111111111111", result.toString());
    }

    @Test
    public void SubTest5() {
        src = new DataType("11111010001000011010110101011001"); //-98456231
        dest = new DataType("11111111111111101000000001001001"); //-98231
        result = alu.sub(dest, src);
        assertEquals("11111010001000110010110100010000", result.toString());
    }

    @Test
    public void SubTest6() {
        src = new DataType("11111111111111111111110000101000"); //-984
        dest = new DataType("00000000000000000000000011100111"); //231
        result = alu.sub(dest, src); //-1215 src - dest
        assertEquals("11111111111111111111101101000001", result.toString());
    }

    @Test
    public void SubTest7() {
        src = new DataType("01111111111111111111111111111111"); // 2147483647
        dest = new DataType("10000000000000000000000000000000"); // -2147483648
        result = alu.sub(dest, src);
        assertEquals("11111111111111111111111111111111", result.toString());
    }

    @Test
    public void SubTest8() {
        src = new DataType("01111111111111111111111111111111"); // 2147483647
        dest = new DataType("10000000000000000000000000000001"); // -2147483647
        result = alu.sub(dest, src);
        assertEquals("11111111111111111111111111111110", result.toString());
    }
}

3.3 32位补码加法

参考
布斯算法
其中 P n P_n Pn​代表的是存储的乘法结果

3.3.1 代码实现
    public DataType mul(DataType src, DataType dest) {
        char[] srcArr = src.toString().toCharArray();
        char[] destArr = dest.toString().toCharArray();
        char[] ansArr = new char[32];
        char[] retArr = new char[32];
        Arrays.fill(retArr, '0');
        Arrays.fill(ansArr, '0');
        int y0 = 0;
        int y1 = 0;
        for (int i = 31; i >= 0; i--) {
            y1 = destArr[i] - '0';
            if (y1 == 1 && y0 == 0) {
//                进行减法，在部分积上减去 被乘数
                ansArr = sub(src, new DataType(new String(ansArr))).toString().toCharArray();
            } else if (y1 == 0 && y0 == 1) {
                ansArr = add(src, new DataType(new String(ansArr))).toString().toCharArray();
            }
            retArr[i] = ansArr[31];
            ansArr = rightMove(ansArr);
            y0 = y1;
        }
        return new DataType(new String(retArr));
    }

    public char[] rightMove(char[] str) {
        for (int i = str.length - 1; i >= 1; i--) {
            str[i] = str[i - 1];
        }
        return str;
    }

需要注意的是：

  1. 32*32位实际上得到的是64位乘法结果，因此我们需要取低32位作为结果
  2. 在这里，我们分别使用ansArr 和retArr 两个数组进行存储
  3. 因为实际上计算时，是高32位进行加减操作，因此我们用ansArr进行加减操作
  4. 同时，用retArr来记录低32位，从而得到结果。
3.3.2 测试用例
package cpu.alu;

import org.junit.Test;
import util.DataType;
import util.Transformer;

import static org.junit.Assert.assertEquals;

public class ALUMulTest {

	private final ALU alu = new ALU();
	private DataType src;
	private DataType dest;
	private DataType result;

	@Test
	public void MulTest1() {
//		11111111111111111111111111111101
		src = new DataType("00000000000000000000000000000110");
		dest = new DataType("11111111111111111111111111111101");
		result = alu.mul(src, dest);
		assertEquals("11111111111111111111111111101110", result.toString());
	}
	@Test
	public void MulTest2() {
//		11111111111111111111111111111101
		src = new DataType("00000000000000000000000000000010");
		dest = new DataType("00000000000000000000000000000010");
		result = alu.mul(src, dest);
		assertEquals("00000000000000000000000000000100", result.toString());
	}

}
小罗丁丁
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
计算机组成原理alu功能实现代码_SAST Weekly | 在？来造计算机！
weixin_39884078的博客
11-24 923
SASTweekly是由电子工程系学生科协推出的科技系列推送，内容涵盖信息领域技术科普、研究前沿热点介绍、科技新闻跟进探索等多个方面，帮助同学们增长姿势，开拓眼界，每周更新，欢迎关注，欢迎愿意分享知识的同学投稿eesast@mail.tsinghua.edu.cn什么是计算机组成？一般提到计算机底层的实现，我们会回想起清华信院学生被《电子电路与系统基础》《计算机组成原理》《计算机体...
计算机组成原理实验——一、ALU实验
qq_50737715的博客
12-31 2749
用 Verilog 设计一个算术运算单元 ALU，采 用纯组合逻辑设计，32bit 宽。1.掌握ALU模块的组成和接口，理解ALU的功 能。3.掌握Verilog中多模块编程方法和实现。2.通过编程调用ALU模块计算斐波那契数。fib.v（三段式斐波那契数列）mysim.v（不用数码管显示）show.v（七段数码管显示）mysim.v（用数码管显示）seven.v（七段数码管）top.v（不用数码管显示）top.v（用数码管显示）alu.v（加法器）div.v（分频器）
计组上机3 ALU：整数加减乘除运算
m0_53632564的博客
12-16 1674
文章目录programming-03 *整数除法整数加法整数减法整数乘法整数除法 programming-03 *整数除法 整数加法 我的方法没有利用全加器，模拟手算过程用最基础的进位方法算的。 全加器的实现 整数减法 取补码即可：注意可以利用“逐位取反到某一位为1停止” 整数乘法 不算很难，主要是先加减再右移的操作，不要漏了某一步。 整数除法 1、对0和溢出的特殊处理 -2^32 / -1 = -2 ^ 32 2、进行过程计算 难点：在所有处理完后修补除法的bug：判断余数和除数的绝对
ALU——调用加法乘法模块
nahnah_的博客
11-24 1633
无
计算机组成原理——算术逻辑单元（ALU）
热门推荐
weixin_43899645的博客
08-18 1万+
与或非 与门 两个数相与，当两个都为1的时候结果才为1，一旦有一个0结果就是0 或门
expri_2_计算机组成原理_
10-02
《计算机组成原理——运算器仿真》 在计算机科学领域，计算机组成原理是研究计算机硬件系统结构的核心课程。它涵盖了从最基础的逻辑门到复杂的CPU设计，以及存储系统、输入/输出设备等各个组成部分的工作原理。其中...
白中英计算机组成原理课件_计算机组成原理_
10-02
《白中英计算机组成原理》是一本深入探讨计算机硬件系统构造的经典教材，涵盖了计算机组成原理的核心概念和技术。这本书由著名教育家白中英教授编写，是学习计算机硬件基础的重要参考资料。"计算机组成原理"作为标签...
计算机组成原理课件_计算机组成原理_
09-30
计算机组成原理是计算机科学与技术领域的一门基础课程，它主要研究计算机系统的基本构造和运行原理。本课程的目的是使学习者理解计算机硬件系统的工作机制，包括数据的表示、运算器设计、存储系统、指令系统、中央...
计算机组成原理-白中英-第五版_计算机组成原理_白中英_
10-01
《计算机组成原理》是计算机科学领域的一本经典教材，由著名计算机科学家白中英教授编著，其第五版更是汇集了多年的教学经验和科研成果。这本书深入浅出地讲解了计算机硬件的基本构造和工作原理，是计算机专业学生和...
zc.rar_组成原理_计算机组成_计算机组成原理
09-19
《计算机组成原理》是计算机科学与技术领域的一门基础课程，它主要研究计算机硬件系统的基本概念、工作原理和设计方法。这门课程的重要性不言而喻，因为理解计算机的内部工作机制是成为一名合格的IT专业人士的基础。...
verilog编写的ALU
09-25
verilog编写，八位ALU，加减与或比较 (verilog prepared eight ALU, subtract, or compare with)
ALU verliog代码
05-16
这是使用verilog编写的ALU的代码
alu实验代码
01-02
实验ALU设计的代码文件 仅供参考 计算机组成原理 实验 一
算术逻辑单元ALU的VHDL代码
02-03
完整的算术逻辑单元（ALU）的 VHDL 代码! 包含其testbench代码！
以32bit加法器为核心的加法、减法、乘法和除法计算器（ALU）
qq_46264636的博客
10-02 1485
实现一个以加法器为核心的计算器。加法：能够实现32bit加法减法：能够实现32bit减法乘法：能够实现两个32bit数字的乘法，乘积为64bit除法：能够实现两个32bit无符号数的除法，商为32bit，余数为32bit解读：该部分的关键在于串并转换，状态数并不多，也没有必要简化；串并转换的关键在于计数器信号和使能信号；而且对于线路空闲时发送无效字节同样很重要，需要借助已存在的或者需要新建信号来支持。
计算机组成原理实验之一：32位ALU的设计
weixin_42746181的博客
11-24 8243
Verilgo HDL 实现简单的32位ALU算术逻辑运算器 接触到EDA软件也有差不多七八个月了，如今学了计算机组成原理，正巧有计组的实验，于是就打算写个系列的博客。 转载需注明出处！ 直接上代码 module alu_32_top( input clkin, input [2:0]sel, output [7:0] scan, output [7:0] seg7 ); wire [31:0] data_temp; alu_32 u0(
计算机组成原理实验2——ALU的设计
XXXXLxu的博客
10-25 7081
加法运算中，011111111+01111111=11111110，两个正数相加，得到了负数，说明发生了溢出，故OF为1；设计总结：把ALU的每个功能所需的部件设计出来，逻辑非用lpm_inv，逻辑与用lpm_and，加减使用lpm_add_sub来实现，最后用选择器选择所需的结果。两组--：100000001+10000010=100000011，舍去进位为00000011，符号位为0，错误，overflow为1；ZF：判断为0.在逻辑非中，11111111的非为00000000，为0，因此ZF=1；
ALU底层方法及计算机整数加减乘除模拟
qq_39345413的博客
01-05 3369
ALU是计算机CPU的核心，即 算术逻辑单元(arithmetic and logic unit) ALU有几大功能，是计算机计算最基础的功能： 1.算术运算：包含加法、减法等 2.逻辑运算：主要是布尔运算，逻辑和、或、非、异或等 3.求补器：计算机中，二进制补码极其重要，可以求一个二进制的补码（源码取反得反码，反码加一得补码） 4.移位器：主要有 算术右移、逻辑右移、左移 5.状态标志：一个记录...
计算机组成原理alu实验
最新发布
04-12
计算机组成原理(ALU)是计算机中的一个重要组成部分，它负责进行算术和逻辑运算。ALU实验是一种通过搭建和设计ALU电路来深入理解计算机组成原理的实践活动。 在ALU实验中，通常会设计一个简单的ALU电路，该电路可以执行基本的算术和逻辑运算，如加法、减法、与、或等。这个电路通常由多个逻辑门和触发器组成，通过组合这些基本的逻辑门和触发器，可以实现复杂的运算功能。 在ALU实验中，你可以学习到以下内容： 1. 逻辑门的基本原理和实现方式，如与门、或门、非门等。 2. 触发器的原理和使用方法，如RS触发器、D触发器等。 3. 运算器的设计和实现，如加法器、减法器等。 4. 控制信号的生成和使用，如选择信号、使能信号等。 通过进行ALU实验，你可以深入理解计算机中的运算原理和数据处理过程。同时，通过设计和搭建ALU电路，你还可以提升自己的逻辑设计和电路实现能力。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值