用x64汇编语言编写384位无符号整数乘法(上)

最新推荐文章于 2024-06-01 10:35:00 发布
最新推荐文章于 2024-06-01 10:35:00 发布
阅读量474 收藏 2
点赞数
文章标签： python c/c++
原文链接：https://my.oschina.net/safedead/blog/376148
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

一、用GCC生成汇编模板
1、编写C语言头文件mul384.h，内容就下面一行
uint64_t mul384(uint64_t c[12], uint64_t a[6], uint64_t b[6]);//c = a * b
2、编写相应C程序文件mul384.c，写个空函数就行了
#include <stdint.h>
#include "mul384.h"
uint64_t mul384(uint64_t c[12], uint64_t a[6], uint64_t b[6])
{
    return 0;
}
3、用GCC编译C程序文件生成汇编文件mul384.s，生成汇编模板文件
gcc -Wall -O2 mul384.c -S

这是mul384.s的全部内容

    .file    "mul384.c"
    .text
    .p2align 4,,15
.globl mul384
    .type    mul384, @function
mul384:
.LFB0:
    .cfi_startproc
    xorl    %eax, %eax
    ret
    .cfi_endproc
.LFE0:
    .size    mul384, .-mul384
    .ident    "GCC: (GNU) 4.4.7 20120313 (Red Hat 4.4.7-11)"
    .section    .note.GNU-stack,"",@progbits

这个mul384.s文件之所以被称为汇编模板，是因为后面编写的汇编代码需要填入下面两句之间

    .cfi_startproc
    .cfi_endproc

替换原先的这两条指令

    xorl    %eax, %eax
    ret
二、算法选择与汇编程序设计
1、C函数接口设计

在x64平台上，无符号整数位宽为64位，一个384位无符号整数需要6个64位无符号整数构成，两个384位无符号整数相乘，其结果需要不超过768位的存储空间，占用12个64位无符号整数空间，故此设计C函数声明为：

uint64_t mul384(uint64_t c[12], uint64_t a[6], uint64_t b[6]);//c = a * b

uint64_t的定义在头文件stdint.h中，因此应用中编译C程序时要包含此头文件。

2、汇编程序输入输出设计

为了提高代码性能，采用“一次输入，一次输出”的内存访问策略，除了最初的输入和最后的输出外，整个运算过程中不访问内存，过程数据全部缓存于SSE寄存器中，为此CPU必须支持SSE42指令集，本文代码只适用于用户态程序，不能用于内核态(不清楚内核态和用户态编程区别的读者请无视这句话)。另外就是调用者传给函数用于输入输出的数组指针a[]、b[]和c[]必须满足16字节对齐要求，否则必将触发CPU错误导致进程崩溃。

3、乘法算法选择

384位乘法在大数运算中属于短位长运算，FFT乘法神马的就别想了，还不够折腾的，Karatsuba算法也不用考虑，对于常用x64处理器来讲，若将基本64位加法指令 addq 耗时设定为1单位，那么带进位64位加法指令 adcq 耗时为2单位，64位无符号乘法指令 mulq 耗时为4单位，综合考虑得失后，采用最基本的分治乘法算法作为本文使用的算法，详细如下：

|====|====|====|====|====|====|====|====|====|====|=====|=====|
|c[0]|c[1]|c[2]|c[3]|c[4]|c[5]|c[6]|c[7]|c[8]|c[9]|c[10]|c[11]|
|====|====|====|====|====|====|====|====|====|====|=====|=====|
|a[0]*b[0]|    |    |    |    |    |    |    |    |     |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |a[0]*b[1]|    |    |    |    |    |    |    |     |     |
|    |a[1]*b[0]|    |    |    |    |    |    |    |     |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |    |a[0]*b[2]|    |    |    |    |    |    |     |     |
|    |    |a[1]*b[1]|    |    |    |    |    |    |     |     |
|    |    |a[2]*b[0]|    |    |    |    |    |    |     |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |    |    |a[0]*b[3]|    |    |    |    |    |     |     |
|    |    |    |a[1]*b[2]|    |    |    |    |    |     |     |
|    |    |    |a[2]*b[1]|    |    |    |    |    |     |     |
|    |    |    |a[3]*b[0]|    |    |    |    |    |     |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |    |    |    |a[0]*b[4]|    |    |    |    |     |     |
|    |    |    |    |a[1]*b[3]|    |    |    |    |     |     |
|    |    |    |    |a[2]*b[2]|    |    |    |    |     |     |
|    |    |    |    |a[3]*b[1]|    |    |    |    |     |     |
|    |    |    |    |a[4]*b[0]|    |    |    |    |     |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |    |    |    |    |a[0]*b[5]|    |    |    |     |     |
|    |    |    |    |    |a[1]*b[4]|    |    |    |     |     |
|    |    |    |    |    |a[2]*b[3]|    |    |    |     |     |
|    |    |    |    |    |a[3]*b[2]|    |    |    |     |     |
|    |    |    |    |    |a[4]*b[1]|    |    |    |     |     |
|    |    |    |    |    |a[5]*b[0]|    |    |    |     |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |    |    |    |    |    |a[1]*b[5]|    |    |     |     |
|    |    |    |    |    |    |a[2]*b[4]|    |    |     |     |
|    |    |    |    |    |    |a[3]*b[3]|    |    |     |     |
|    |    |    |    |    |    |a[4]*b[2]|    |    |     |     |
|    |    |    |    |    |    |a[5]*b[1]|    |    |     |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |    |    |    |    |    |    |a[2]*b[5]|    |     |     |
|    |    |    |    |    |    |    |a[3]*b[4]|    |     |     |
|    |    |    |    |    |    |    |a[4]*b[3]|    |     |     |
|    |    |    |    |    |    |    |a[5]*b[2]|    |     |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |    |    |    |    |    |    |    |a[3]*b[5]|     |     |
|    |    |    |    |    |    |    |    |a[4]*b[4]|     |     |
|    |    |    |    |    |    |    |    |a[5]*b[3]|     |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |    |    |    |    |    |    |    |    |a[4]*b[5] |     |
|    |    |    |    |    |    |    |    |    |a[5]*b[4] |     |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |    |    |    |    |    |    |    |    |    | a[5]*b[5] |
|====|====|====|====|====|====|====|====|====|====|=====|=====|
4、寄存器规划

以高性能运算为目的的汇编语言编程设计中，寄存器规划是重中之重，还好384位乘法对x64处理器来讲只是入门级小菜，所以我用了两周时间完成了寄存器规划，详细使用规划如下：

(1).rdi是输出数据c[]的首地址，rsi是输入数据a[]的首地址，rdx是输入数据b[]的首地址

(2).xmm0 ~ xmm5这个6个SSE寄存器用于缓存运算过程与结果数据
|---------|---------|---------|---------|---------|-----------|
|  %xmm0  |  %xmm1  |  %xmm2  |  %xmm3  |  %xmm4  |  %xmm5    |
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|c[0]|c[1]|c[2]|c[3]|c[4]|c[5]|c[6]|c[7]|c[8]|c[9]|c[10]|c[11]|
|----|----|----|----|----|----|----|----|----|----|-----|-----|

(3).xmm6 ~ xmm8这个6个SSE寄存器用于输入数据a和b
|---------|---------|---------|---------|---------|---------|
|  %xmm6  |  %xmm7  |  %xmm8  |  %xmm6  |  %xmm7  |  %xmm8  |
|----|----|----|----|----|----|----|----|----|----|----|----|
|a[0]|a[1]|a[2]|a[3]|a[4]|a[5]|b[0]|b[1]|b[2]|b[3]|b[4]|b[5]|
|----|----|----|----|----|----|----|----|----|----|----|----|

(4).xmm14和xmm15用于r12 ~ r15的备份与恢复
|---------|---------|
| %xmm14  | %xmm15  |
|----|----|----|----|
|%r12|%r13|%r14|%r15|
|----|----|----|----|

(5).r10 ~ r15用于乘法指令mulq的操作数，其数值固定
|----|----|----|----|----|----|
|%r10|%r11|%r12|%r13|%r14|%r15|
|----|----|----|----|----|----|
|a[1]|a[3]|a[5]|b[1]|b[3]|b[5]|
|----|----|----|----|----|----|

(6).r8, r9, rsi三个通用寄存器用于累加过程，循环使用
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|c[0]|c[1]|c[2]|c[3]|c[4]|c[5]|c[6]|c[7]|c[8]|c[9]|c[10]|c[11]|
|----|----|----|----|----|----|----|----|----|----|-----|-----|
|    |%r8 |%r9 |%rsi|%r8 |%r9 |%rsi|%r8 |%r9 |%rsi|%r8  |%r9  |
|----|----|----|----|----|----|----|----|----|----|-----|-----|


转载于:https://my.oschina.net/safedead/blog/376148

weixin_33737774
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
汇编语言用十六位乘法指令完成三十二位无符号数乘法
02-19
大学期间微机原理的课设，通过使用汇编语言，用16位乘法指令实现32位无符号数乘法的程序，希望能为后来者提供一些启发
计算机组成原理课程设计 汇编语言+唐都实验箱 原码带符号一位乘法
04-12
基于所学计算机组成原理的知识，使用汇编语言和微指令+唐都实验箱，并在此基础上完成有符号位原码的一位乘法的运算。
c语言 f8x16,用x64汇编语言编写384位无符号整数乘法(下)
weixin_39953845的博客
05-21 337
三、测试与总结1、用C语言编写一个自测程序test1.c#include#include#include#include#include#include"mul384.h"intmain(intargc,char*argv[]){uint64_ta[6],b[6],c[12],i;//初始化数据a[5]=0xEEEEEEEEEEEEEEEE;a[4]...
用x64汇编语言编写384位无符号整数乘法(下)
weixin_33800593的博客
02-06 172
2019独角兽企业重金招聘Python工程师标准>>> ...
用x64汇编语言编写384位无符号整数乘法(中)
weixin_33881041的博客
02-06 313
2019独角兽企业重金招聘Python工程师标准>>> ...
算法训练 P0501 用位操作实现无符号整数的乘法运算
Nicolas的博客
01-31 1319
题目链接 首先实现二进制加法： 位的异或运算跟求'和'的结果一致： 异或 1^1=0 1^0=1 0^0=0 求和 1+1=0 1+0=1 0+0=0 位的与运算跟求'进位‘的结果一致： 位与 1&amp;1=1 1&amp;0=0 0&amp;0=0 进位 1+1=1 1+0=0 0+0=0 题目已经给出整数为正，否则需要在运算时将整数转换为相应的正整数。 #include &...
VS2010中编写x64汇编的具体方法.docx
12-30
但是当目标平台为x64时，微软不再允许直接内联汇编了，这给我们编程造成了一些不便。 怎么解决这个问题呢？ 一种办法是改用Intel的编译器，它仍然支持内联汇编。 另一种办法还是用VS了，但是不能内联，需要把汇编...
32位无符号乘法/递归调用程序
06-28
微机原理课设程序设计
windows环境下64位汇编语言程序设计
10-14
windows环境下64位汇编语言程序设计 作者：JoenChen 。是把罗云彬的32位移植到64位。
无符号整数
sssdffa的专栏
07-22 2165
这个层次可以导致了一些有趣的问题。例如，您可能希望表达对5U - 10 - 5（5U意味着5为无符号整数）。但在这种情况下，符号整数（10）提高到一个无符号整数，和这个表达式的结果是无符号整数4294967291！ 许多混合转换按预期工作。例如，int值= 10×2.7的结果27。10是提升到一个浮动，10×2.7的值为27，和27被截断为整数（即编译器会抱怨）。 许多新的程序员尝试这
汇编语言中乘法指令详解（IMUL:有符号乘指令,MUL:无符号乘指令）
01-07
1、有符号乘指令 （1）双操作数的有符号乘指令 语句格式  ：IMUL OPD ,OPS 功       能  ：（OPD）*（OPS）—->OPD 其中OPD可为16/32的寄存器，OPS可为同类型的寄存器、存储器操作数或立即数。 （2）3个操作数的有符号乘指令 语句格式  ：IMUL OPD ,OPS, N 功       能  ：（OPS*N）—–>OPD 其中OPD可为16/32的寄存器，OPS可为同类型的寄存器、存储器操作数,n为立即数。 （3）单操作数的有符号乘指令  语句格式   ：IMUL OPS 功       能    :字节乘法：（AL）*（OPS）—->AX      
C语言编写无符号大整数运算
12-23
使用c语言实现的无符号大整数的加、减、乘、除（取整和求余运算），可直接运行
64位整数乘法
Mintind的博客
03-24 562
64位整数乘法 求 a 乘 b 对 p 取模的值。 输入格式 第一行输入整数a，第二行输入整数b，第三行输入整数p。 输出格式 输出一个整数，表示a*b mod p的值。 数据范围 1≤a,b,p≤1018 看到这个数据范围有点茫然 跑去查了下unsigned long long 最近做题的时候，经常遇到范围是263，取模264的这种题目。遇到这种限制条件时就要想到用unsigned long...
gcc 64-bit 汇编阶乘算法
Nulizhu的专栏
04-11 1102
gcc asm关键字用法，以及简单汇编的写法
乘法指令与乘加指令
weixin_33756418的博客
01-11 928
ARM 微处理器支持的乘法指令与乘加指令共有6 条，可分为运算结果为32 位和运算结果为64 位两类，与前面的数据处理指令不同，指令中的所有操作数、目的寄存器必须为通用寄存器，不能对操作数使用立即数或被移位的寄存器，同时，目的寄存器和操作数1 必需时不同的寄存器。 乘法指令与乘加指令共有以下6 条： 1、 MUL 指令 MUL 指令的格式为： MUL{条件}{S...
如何mysql数据导入到mongdb
codemami的博客
05-30 1445
由于MySQL和MongoDB的数据模型不同（例如，MySQL使用关系模型，而MongoDB使用文档模型），你可能需要转换数据的格式。使用MongoDB驱动程序：你也可以使用MongoDB的官方驱动程序（如Python的pymongo）来编写脚本，将数据直接插入到MongoDB中。注意：如果你的JSON文件包含多个文档，并且它们不是作为数组的一部分（即每个文档都在其自己的行上），则需要使用--jsonArray选项。手动转换：对于小型数据集，你可以手动编辑SQL或CSV文件，将其转换为JSON格式。
专属编程笔记
最新发布
u014397365的博客
06-01 960
在软件开发中，Utils（或Utilities）目录通常用于存放一些。这些工具类或函数为整个应用程序或多个模块提供便利的功能支持，使得代码更加模块化、易于维护和重用。UtilsUtils目录的设计目的在于避免代码重复，并确保在整个项目中以一致的方式处理共通任务。这样做可以提高开发效率，降低维护成本，并确保代码的整洁性和可读性。
在linux服务器上使用tensorboard，错误记录
wwwwzm的博客
05-30 1155
1. 使用tensorboard命令时，不是从虚拟环境中找tensorboard，而是从（全局路径）中找（/home/ljx/.local/lib/python3.9/site-packages/tensorboard）是一个在 Unix-like 系统（包括 Linux 和 macOS）的命令行界面（如 Bash shell）中使用的命令。2.使用which命令， 查看使用的tensorboard的路径，发现使用的是全局路径，不是虚拟环境路径。是一个特殊的变量，它定义了操作系统搜索可执行文件的目录。
基于NANO 9K 开发板加载PICORV32软核，并建立交叉编译环境
pocean2012的博客
05-30 1162
ISP的实现逻辑是出厂“芯片”（我们这里是软核）自带了BootLoader程序，即出厂引导程序，通过BootLoader可以将程序从串口（上位机）下载到Flash中，实际的时序是通过RST来区分正常启动还是烧录状态，然后上位机的烧录脚本来控制串口时序， 用户程序实际上是通过串口最终下载到了FLASH中，然后程序从flash启动。NANO 9K低成本体验FPGA开发，还是挺香的，官方例子有加载PICORV32软核的例子，可以建立简单的ISP编程环境，通过串口就可以加载程序，很方便。
用8086汇编语言完成十六位乘法指令完成三十二位无符号数乘法（结果64位）
05-27
下面是用8086汇编语言实现三十二位无符号数乘法的代码： ``` ; 32-bit unsigned multiplication using 16-bit multiplication instructions mul32: push bx ; save bx register value push cx ; save cx register value ; load operands into registers mov ax, word ptr [si] ; load lower word of operand 1 into ax mov bx, word ptr [si + 2] ; load upper word of operand 1 into bx mov cx, word ptr [di] ; load lower word of operand 2 into cx mov dx, word ptr [di + 2] ; load upper word of operand 2 into dx ; perform multiplication mul cx ; multiply lower words mov si, ax ; save lower word of result mov ax, bx ; move upper word of operand 1 to ax mul cx ; multiply lower word of operand 1 with upper word of operand 2 add si, ax ; add result to lower word of result mov ax, word ptr [si - 2] ; load lower word of result into ax mov bx, word ptr [si] ; load upper word of result into bx mul dx ; multiply upper words add bx, ax ; add result to upper word of result ; store result in memory mov word ptr [di], si ; store lower word of result in memory mov word ptr [di + 2], bx ; store upper word of result in memory pop cx ; restore cx register value pop bx ; restore bx register value ret ; return from function ``` 这段代码使用了16位乘法指令MUL来完成32位的无符号数乘法操作。它首先将操作数加载到AX、BX、CX和DX寄存器中，然后使用MUL指令将低位相乘并将结果存储在SI寄存器中，接着将BX中的高位移动到AX中，再次使用MUL指令将其与CX中的低位相乘，并将结果加到SI中。然后将SI寄存器中的低位和高位分别移动到AX和BX中，并再次使用MUL指令将DX中的高位与AX中的低位相乘，并将结果加到BX中。最后，将结果存储在目标地址中。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值