CN101981542B

CN101981542B - 多项式数据处理运算

Info

Publication number: CN101981542B
Application number: CN2009801105915A
Authority: CN
Inventors: D·H·赛姆斯; D·克肖; M·C·维策伦伯格
Original assignee: Advanced Risc Machines Ltd
Current assignee: U Blox AG
Priority date: 2008-03-26
Filing date: 2009-01-26
Publication date: 2013-10-16
Anticipated expiration: 2029-01-26
Also published as: EP2255279B1; KR20100139072A; IL207633A0; EP2255279A1; GB0805491D0; US20090248780A1; WO2009118500A1; ATE521936T1; GB2458665B; JP5193358B2; MY158872A; US8700688B2; CN101981542A; GB2458665A; JP2011517496A; TW200945062A

Abstract

一种数据处理系统(2)包括响应于多项式除法指令DIVL.P_N来生成控制信号的指令解码器(22)，所述控制信号控制处理电路(26)执行多项式除法运算。分母多项式由存储在寄存器内的分母值表示，其中假设该多项式的最高次项总是具有系数“1”以使得不需要将该系数存储在存储分母值的寄存器内并且因此该分母多项式可以具有比可能对于单独存储分母值的寄存器内的位空间高一次的次数。多项式除法指令返回分别表示商多项式和余数多项式的商值和余数值。

Description

多项式数据处理运算

技术领域

本发明涉及数据处理系统的领域。更特别地，本发明涉及提供对多项式数据处理运算的支持的数据处理系统。

背景技术

已知在数据处理系统中提供一些对多项式算法的支持。例如，已知提供对与里德索罗门(Reed Solomon)编码或椭圆曲线密码术(EllipticCurve Cryptography)相关联的多项式算法的支持。一种提供这样的支持的已知数据处理系统是由德州仪器公司(Texas Instruments)生产的被称为TMS320C64x的数字信号处理器。这些数字信号处理器提供执行下列运算的指令：

a＝b*c mod p(其中b是32位且c是9位)，并且

其中p被保持在特定的32位寄存器中(GPLYA或GPLYB)。

该多项式指令的已知形式产生多项式乘法的余数部分，从而提供对里德索罗门编码的良好支持。这不适合于其他形式的多项式数据处理，例如与传输代码的计算或信号加扰相关联的多项式数据处理。

还已知为了信号加扰或生成传输代码的目的而提供特定用途硬件。这样的特定用途硬件可以以能够以高速执行必需的计算的形式来提供，但是具有的缺点是：消耗了用于该专用功能的重要电路资源以及是相对不灵活的(inflexible)并且不适合于重复使用和/或修改。

发明内容

从本发明的一个方面来看提供了用于处理数据的装置，该装置包括：

响应于程序指令来生成一个或多个控制信号的指令解码器；

具有多个寄存器的寄存器库(register bank)；以及

处理电路，其耦合到所述指令解码器和所述寄存器库并且响应于所述一个或多个控制信号来对存储在所述寄存器库中的一个或多个数据值执行对应于所述程序指令的数据处理运算；其中

所述指令解码器响应于作为单个指令的多项式除法指令来生成一个或多个控制信号，其控制所述处理电路至少生成表示用分母多项式去除分子多项式的二元域内的多项式除法的商多项式的商值作为存储在所述多个寄存器中的输出，所述分母多项式是由c_ixⁱ(N≥i≥0)的和给出的N次多项式，其中c(N-1)到c₀表示存储在所述寄存器库的寄存器中的相应位，以及c_N＝1并且没有被存储在所述寄存器中。

本技术提供一种可编程数据处理装置，其具有通用元件，例如指令解码器、寄存器库和处理电路，所述处理电路具有另外提供多项式除法指令的能力，其至少生成表示由多项式除法产生的商多项式的商值。此外，分母多项式被以下述形式存储在寄存器库的寄存器内，所述形式即多项式的最高次项的系数被固定为“1”并且假设不需要被存储在寄存器内。这允许分母多项式具有比被用于存储分母值的位宽度高一次的次数，从而允许更有效地使用寄存器库的寄存器内表示多项式除法的结果的位空间，以便更容易地与可能结果的最大位宽度匹配。

存储分母多项式的系数的寄存器可以是N位寄存器。

尽管要操作的多项式可以由存储在寄存器内的值以各种不同形式来表示，但是通过将不同项的系数存储在寄存器内所存储的值的相应位位置处来表示它们更方便。

可以以不同的顺序在寄存器内所保持的值中存储所述系数，例如将最低次项的系数存储在最高有效位位置处进行到将最高次项的系数存储在最低有效位位置处，或者正好相反(例如类似于低位在前或高位在前存储)。

分子多项式通常具有比分母多项式更高的次数，并且因此方便的实施例用存储在寄存器库内的两个N位存储器或一个2N位寄存器(当在该寄存器库内提供有这样的更宽寄存器(例如累加寄存器)的时候)内的2N位分子值来表示分子多项式。

多项式除法指令还可以生成表示由多项式除法产生的余数多项式的余数值以及表示商多项式的商值。当商多项式用于生成加扰信号、传输代码等等时，余数多项式还用于其他情况，并且因此在根据多项式除法指令生成这二者的情况下是方便的。

余数值和商值可以被方便地存储在寄存器库的相应N位寄存器内。

当所使用的寄存器库包括由程序指令而非多项式除法指令使用的多个通用标量寄存器时，实施该技术的效率被改进。

当数据处理系统另外提供结合上述多项式除法指令的多项式乘法指令时，并入了多项式除法指令的该数据处理系统的普遍适用性以及针对各种函数重复使用该系统的能力被增强。

尽管通常可能需要标量形式的多项式除法指令，但是在一些实施例中还有可能期望提供作为矢量指令的多项式除法指令，其中分母值是标量值，因为所述分母值通常将并不频繁地改变并且需要被应用于长矢量序列的分子值以生成矢量序列的商值。

从本发明的另一个方面来看提供了一种处理数据的方法，其包括下述步骤：

解码程序指令以生成一个或多个控制信号；

响应于所述一个或多个控制信号，对存储在具有多个寄存器的寄存器库中的一个或多个数据值执行对应于所述程序指令的数据处理运算；其中

所述解码响应于作为单个指令的多项式除法指令来生成一个或多个控制信号，该一个或多个控制信号控制至少生成表示用分母多项式去除分子多项式的二元域上的多项式除法的商多项式的商值作为存储在所述多个寄存器中的输出，所述分母多项式是由c_ixⁱ(N≥i≥0)的和给出的N次多项式，其中c(N-1)到c₀表示存储在所述寄存器库的寄存器中的相应位，以及c_N＝1并且没有被存储在所述寄存器中。

将会认识到本发明的又一个方面是提供计算机程序，所述计算机程序并入了上文所讨论的以控制根据本技术的硬件的多项式除法指令。

附图说明

现在将参考附图描述仅以示例方式给出的本发明的实施例，其中：

图1示意性地示出包括对多项式除法指令的支持的数据处理装置；

图2示意性地示出多项式除法指令的语法；

图3示意性地示出示例多项式除法运算；

图4示意性地示出用于响应于多项式除法指令执行多项式除法运算的电路；

图5示出矢量多项式除法指令的示例语法；

图6示出两种可替换的方式，其中多项式可以由存储在寄存器中的值表示；以及

图7示意性地示出多项式乘法指令的语法。

具体实施方式

图1示出采用耦合到存储器6的处理器4的形式的数据处理装置2。存储器6存储程序指令8(例如用于执行信号加扰的程序指令)，以及经历处理运算的数据值(例如形成要被加扰并传输的流的数据值10)。

处理器4包括由N位寄存器(例如32位寄存器)构成的寄存器库12和(可选地)一些2N位寄存器14，所述2N位寄存器14被提供用作与乘法累加指令相关联的累加寄存器。包括乘法器16、移位器18和加法器20的处理元件在由指令解码器22生成的控制信号的控制下响应于在从存储器6提取程序指令时沿着指令管线24进行程序指令处理来执行处理运算。处理器4是具有标量寄存器库12、14的通用处理器，所述标量寄存器库12、14用于响应于从存储器6提取的程序指令来执行通用数据处理运算，例如标准逻辑和算术运算。由指令解码器22生成的控制信号配置数据处理元件16、18、20以执行所期望的数据处理运算。

此外，在处理器4内提供多项式除法电路26，其响应于由指令解码器22生成的控制信号来(经由寄存器12、14)对从存储器6检索到的数据值执行多项式除法运算。将在下文中进一步描述这些多项式除法运算和多项式除法指令。

图2示意性地示出多项式除法指令DIVL.Pn的语法。在语法DIVL.Pn(以及随后讨论的代码中的divl_pn)中，“n”是运算的宽度(例如8、16或32)，并且可以小于寄存器的宽度“N”。在下面的示例中，假设N＝n，但是将会认识到当N≠n时(例如N＝32且n＝8、16或32)还可以应用本技术。多项式除法指令使用三个寄存器来保持其输入运算数。在该示例中，这些寄存器是寄存器库12内的N位寄存器。表示分子多项式的分子值被存储在寄存器r0和r1中。分子值因此是2N位值。表示分母多项式的分母值被存储在寄存器r2中。分母值表示分母多项式，其中假设该分母多项式以其具有系数“1”的最高次项开始，并且因此分母值仅需要表示所述最高次项之后的各项的系数。这允许分母多项式包括比寄存器r2的宽度大一的最大项数。这是一个优点，因为根据这样的多项式除法而得到的余数值将具有比分母值小一的位长，并且因此在寄存器r2和其中存储有余数值的寄存器(r4)具有相同的宽度时所述余数值将必定适合寄存器大小，而不会浪费寄存器位空间。因此，在32位寄存器的情况下，分母商可以具有33个项并且余数商可以具有32个项。

如将在图2中看到的那样，多项式除法指令DIVL.Pn将表示商多项式的商值返回到寄存器r3中，并且将表示余数多项式的余数值返回到寄存器r4中。在所示出的语法中，将会看到除了具有由存储在寄存器r2中的分母值的位指定的系数的项之外，分母商还被扩展成具有最高次项x^N。分子多项式将由存储在寄存器r1内的系数所指定的项作为其高次部分(被表示为通过乘以x^N增加到高次部分)，其中利用具有从寄存器r0得到的系数的项来形成分子多项式的低次部分。

将会看到，在该一般的语法中由变量N表示被操作的多项式的次数。将会认识到，根据数据处理需求，这可以采用各种不同的值，并且被操作的多项式可以是例如8、16或32次。N的其他值也是可以的。

在N＝32的情况下，一种检查多项式除法指令的方式是其给出等同于下面的C程序代码的结果：

poly32_t q＝x0，r＝x1，p＝x2；

int C，i；

for(i＝0；i＜32；i++)

{

C＝r＞＞31；

r＝r＜＜1；

if(C)

{

r＝r^p；

}

if(q＞＞31)

{

r＝r^1；

}

q＝(q＜＜1)|C；

}

*x3＝q；/*((x1＜＜32)+x0)div((1＜＜32)+x2)*/

return r；/*((x1＜＜32)+x0)mod((1＜＜32)+x2)*/

图3示意性地示出示例多项式除法运算。在这种情况下，N＝4产生具有多达5个项的分母多项式以及多达8个项的分子多项式。在所说明的示例中，分母多项式项x³和x的系数都是零。因此，分母多项式是x⁴+x²+1。存储在寄存器r2内的分母值是“0101”，并且在其最高有效端处扩展了值“1”以给出分母多项式的各系数，因为假设分母多项式内的最高次项总是具有系数“1”。本领域技术人员将会认识到这样的假设可能需要分母多项式的排列与任何分子多项式中的关联排列，以便该假设是正确的。然而，分母多项式通常是准固定的值并且因此一般不是每个计算都需要这样的分母多项式对齐。此外，分子多项式通常是数据流并且因此一般通过挑选适当的开始点来实现这样的数据流内的对齐。

多项式除法指令的作用类似于长除法指令。在二元域(即项的系数可以是“0”或“1”)上的多项式算法中，加法和减法等同于异或函数。乘法等同于与运算。就相同次数的项执行这些运算。在所示出的示例中，由多项式除法指令产生的商多项式是“x³+x²+x”并且这由商值“1110”表示。余数多项式是“1”并且这由余数值“0001”表示。

图4示意性地示出了用于实施例如可以由图1的多项式除法电路26提供的4次多项式除法指令的电路。如将会看到的那样，用于响应于多项式除法指令来执行多项式除法运算的电路包括与门和异或门的布置。这些门的输入是分子值[n₇:n₀]和分母值[1:p₀]。

图4中的电路由指令解码器22响应于多项式除法指令而生成的控制信号控制，其中电路被激活以供使用，并且从寄存器库12中读出分子值和分母值并且将它们提供给图4的电路的输入端。此外，类似地从图4的电路的输出端读取商值[q₃:q₀]和余数值[r₃:r₀]，并且将它们存储回到寄存器库12内的寄存器中。在该示例中，将两个写入端口提供给寄存器库12以便允许将商值、余数值二者都写入到其中。

将会认识到，图4的电路用于计算4次多项式的除法。然而，该电路的规则扩展为更高次的多项式除法提供多项式除法指令运算，并且实际上，相同电路可以通过利用信号值的适当多路传输(multiplexing of signal value)而重复用于这些不同次的除法，如本领域技术人员所熟悉的那样。

下面给出用于执行32、16或8次多项式除法的寄存器传送语言(RTL)限定电路的示例。

＞//Polynomial divider

＞

//---------------------------------------------------

---------

＞

＞ //------------------------------------------

＞ //Divider Ex stage

＞ //------------------------------------------

＞ always(posedge clk)

＞ if(cmd_div_en)begin

＞ d_din_h_ex ＜＝din_a_sz；

＞ d_poly_ex ＜＝din_b_sh；

＞ end

＞

＞ //Common terms

＞ assign d_i ＝d_din_h_ex；

＞ assign d_p＝d_poly_ex；

＞ assign d_p_29＝d_p[30]^d_p[31]；

＞ assign d_p_28＝d_p[29]^d_p[31]；

＞ assign d_p_27＝d_p[28]^(d_p[30]|d_p[31])；

＞ assign d_p_26＝d_p[27]^(d_p[31]&～(d_p[29]^d_p[30]))；

＞ assign d_p_25＝d_p[26]^d_p[29]^(d_p[31]&d_p[28])^(d_p[31]

＞|d_p[30])；

＞

＞ //Divider-1 st 8-bits

＞ assign d_o[31]＝d_i[31]；

＞ assign d_o[30]＝d_i[30] ^

＞ (d_i[31]&d_p[31])；

＞ assign d_o[29]＝d_i[29] ^

＞ (d_i[30]&d_p[31]) ^

＞ (d_i[31]&d_p_29)；

＞ assign d_o[28]＝d_i[28] ^

＞ (d_i[31]&d_p_28) ^

＞ (d_i[30]&d_p_29) ^

＞ (d_i[29]&d_p[31])；

＞ assign d_o[27]＝d_i[27] ^

＞ (d_i[28]&d_p[31]) ^

＞ (d_i[29]&d_p_29) ^

＞ (d_i[30]&d_p_28) ^

＞ (d_i[31]&d_p_27)；

＞ assign d_o[26]＝d_i[26] ^

＞ (d_i[27]&d_p[31]) ^

＞ (d_i[28]&d_p_29) ^

＞ (d_i[29]&d_p_28) ^

＞ (d_i[30]&d_p_27) ^

＞ (d_i[31]&d_p_26)；

＞ assign d_o[25]＝d_i[25] ^

＞ (d_i[26]&d_p[31]) ^

＞ (d_i[27]&d_p_29) ^

＞ (d_i[28]&d_p_28) ^

＞ (d_i[29]&d_p_27) ^

＞ (d_i[30]&d_p_26) ^

＞ (d_i[31]&(d_p[26]^d_p[29]^(d_p[31]&

＞ d_p[28])^(d_p[31]|d_p[30])))；assign d_o[24]＝d_i[24] ^

＞ (d_i[25]&d_p[31]) ^

＞ (d_i[26]&d_p_29) ^

＞ (d_i[27]&d_p_28) ^

＞ (d_i[28]&d_p_27) ^

＞ (d_i[29]&d_p_26) ^

＞ (d_i[30]&(d_p[26]^d_p[29]^(d_p[31]&

＞ d_p[28])^(d_p[31]|d_p[30])))^(d_i[31]&

＞ d_p[25])^(d_i[31]&d_p[31]&d_p[27]) ^

＞ (d_i[31]&d_p[30]&d_p[29]) ^

＞ (d_i[31]&d_p[31])；

＞ assign dpp_31＝{{1{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[31]}}&

＞ d_poly_ex)，{31{1′b0}}}；assign dpp_30＝{{2{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[30]}}&d_poly_ex)，{30{1′b0}}}；assign

＞ dpp_29＝{{3{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[29]}}&d_poly_ex)，

＞ {29{1′b0}}}；assign dpp_28＝{{4{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[28]}}&d_poly_ex)，{28{1′b0}}}；assign

＞ dpp_27＝{{5{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[27]}}&d_poly_ex)，

＞ {27{1′b0}}}；assign dpp_26＝{{6{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[26]}}&d_poly_ex)，{26{1′b0}}}；assign

＞ dpp_25＝{{7{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[25]}}&d_poly_ex)，

＞{25{1′b0}}}；assign dpp_24＝{{8{1′b0}}，

＞({`AR1DPU_INT_WIDTH{d_o[24]}}&d_poly_ex)，{24{1′b0}}}；assign

＞dp_24＝(({d_i，{32{1′b0}}}^dpp_31)^dpp_28)^((dpp_30^dpp_29)

＞^dpp_27)^(dpp_26^dpp_25)^dpp_24；

＞

＞ //Divider -2nd 8-bits

＞ assign d_o[23]＝dp_24[23+32]；

＞ assign d_o[22]＝dp_24[22+32] ^

＞ (dp_24[23+32]&d_p[31])；

＞ assign d_o[21]＝dp_24[21+32] ^

＞ (dp_24[22+32]&d_p[31]) ^

＞ (dp_24[23+32]&d_p_29)；

＞ assign d_o[20]＝dp_24[20+32] ^

＞ (dp_24[23+32]&d_p_28) ^

＞ (dp_24[22+32]&d_p_29) ^

＞ (dp_24[21+32]&d_p[31])；

＞ assign d_o[19]＝dp_24[19+32] ^

＞ (dp_24[20+32]&d_p[31]) ^

＞ (dp_24[21+32]&d_p_29) ^

＞ (dp_24[22+32]&d_p_28) ^

＞ (dp_24[23+32]&d_p_27)；

＞ assign d_o[18]＝dp_24[18+32] ^

＞ (dp_24[19+32]&d_p[31]) ^

＞ (dp_24[20+32]&d_p_29) ^

＞ (dp_24[21+32]&d_p_28) ^

＞ (dp_24[22+32]&d_p_27) ^

＞ (dp_24[23+32]&d_p_26)；

＞ assign d_o[17]＝dp_24[17+32] ^

＞ (dp_24[18+32]&d_p[31]) ^

＞ (dp_24[19+32]&d_p_29) ^

＞ (dp_24[20+32]&d_p_28) ^

＞ (dp_24[21+32]&d_p_27) ^

＞ (dp_24[22+32]&d_p_26) ^

＞ (dp_24[23+32]&(d_p[26]^d_p[29]^(d_p[31]&

＞ d_p[28])^(d_p[31]|d_p[30])))；assign d_o[16]＝dp_24[16+32] ^

＞ (dp_24[17+32]&d_p[31]) ^

＞ (dp_24[18+32]&d_p_29) ^

＞ (dp_24[19+32]&d_p_28) ^

＞ (dp_24[20+32]&d_p_27) ^

＞ (dp_24[21+32]&d_p_26) ^

＞ (dp_24[22+32]&(d_p[26]^d_p[29]^(d_p[31]&

＞ d_p[28])^(d_p[31]|d_p[30])))^(dp_24[23+32]&

＞ d_p[25])^(dp_24[23+32]&d_p[31]&d_p[27]) ^

＞ (dp_24[23+32]&d_p[30]&d_p[29]) ^

＞ (dp_24[23+32]&d_p[31])；

＞ assign dpp_23＝{{9{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[23]}}&

＞ d_poly_ex)，{23{1′b0}}}；assign dpp_22＝{{10{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[22]}}&d_poly_ex)，{22{1′b0}}}；assign

＞ dpp_21＝{{11{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[21]}}&d_poly_ex)，

＞ {21{1′b0}}}；assign dpp_20＝＝{{12{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[20]}}&d_poly_ex)，{20{1′b0}}}；assign

＞ dpp_19＝＝{{13{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[19]}}&d_poly_ex)，

＞ {19{1′b0}}}；assign dpp_18＝＝{{14{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[18]}}&d_poly_ex)，{18{1′b0}}}；assign

＞ dpp_17＝{{15{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[17]}}&d_poly_ex)，

＞{17{1′b0}}}；assign dpp_16＝{{16{1′b0}}，

＞({`AR1DPU_INT_WIDTH{d_o[16]}}&d_poly_ex)，{16{1′b0}}}；assign

＞dp_16＝((dp_24^dpp_23)^dpp_20)^((dpp_22^dpp_21)^dpp_19) ^

＞(dpp_18^dpp_17)^dpp_16；

＞

＞ //--------------------------------------------

＞ //Divider Ex2 stage

＞ //--------------------------------------------

＞ //Note that d_poly_ex is re-used in Ex2(it must not change！)

＞ //REVISIT，merge Ex and Ex2 stages to reduce area

＞

＞ always(posedge clk)

＞ if(cmd_div_ex)begin

＞ d_din_1_ex2＜＝din_b_sh；

＞ dp_ex2＜＝{d_o[31:16]，dp_16[47:0]}；

＞ end

＞

＞ //Divider-l st 8-bits

＞ assign d_o[15]＝dp_ex2[15+32]；

＞ assign d_o[14]＝dp_ex2[14+32] ^

＞ (dp_ex2[15+32]&d_p[31])；

＞ assign d_o[13]＝dp_ex2[13+32] ^

＞ (dp_ex2[14+32]&d_p[31]) ^

＞ (dp_ex2[15+32]&d_p_29)；

＞ assign d_o[12]＝dp_ex2[12+32] ^

＞ (dp_ex2[13+32]&d_p[31]) ^

＞ (dp_ex2[14+32]&d_p_29) ^

＞ (dp_ex2[15+32]&d_p_28)；

＞ assign d_o[11]＝dp_ex2[11+32] ^

＞ (dp_ex2[12+32]&d_p[31]) ^

＞ (dp_ex2[13+32]&d_p_29) ^

＞ (dp_ex2[14+32]&d_p_28) ^

＞ (dp_ex2[15+32]&d_p_27)；

＞ assign d_o[10]＝dp_ex2[10+32] ^

＞ (dp_ex2[11+32]&d_p[31]) ^

＞ (dp_ex2[12+32]&(d_p[31]^d_p[30])) ^

＞ (dp_ex2[13+32]&d_p_28) ^

＞ (dp_ex2[14+32]&d_p_27) ^

＞ (dp_ex2[15+32]&d_p_26)；

＞ assign d_o[9]＝dp_ex2[9+32] ^

＞ (dp_ex2[10+32]&d_p[31]) ^

＞ (dp_ex2[11+32]&(d_p[31]^d_p[30])) ^

＞ (dp_ex2[12+32]&d_p_28) ^

＞ (dp_ex2[13+32]&d_p_27) ^

＞ (dp_ex2[14+32]&d_p_26) ^

＞ (dp_ex2[15+32]&(d_p[26]^d_p[29]^(d_p[31]&

＞ d_p[28])^(d_p[31]|d_P[30])))；assign d_o[8]＝dp_ex2[8+32] ^

＞ (dp_ex2[9+32]&d_p[31]) ^

＞ (dp_ex2[10+32]&(d_p[31]^d_p[30])) ^

＞ (dp_ex2[11+32]&d_p_28) ^

＞ (dp_ex2[12+32]&d_p_27) ^

＞ (dp_ex2[13+32]&d_p_26) ^

＞ (dp_ex2[14+32]&(d_p[26]^d_p[29]^(d_p[31]&

＞ d_p[28])^(d_p[31]|d_p[30])))^(dp_ex2[15+32]

＞ &d_p[25])^(dp_ex2[15+32]&d_p[31]&d_p[27]) ^

＞ (dp_ex2[15+32]&d_p[30]&d_p[29]) ^

＞ (dp_ex2[15+32]&d_p[31])；

＞ assign dpp_15＝{{17{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[15]}}&

＞ d_poly_ex)，{15{1′b0}}}；assign dpp_14＝{{18{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[14]}}&d_poly_ex)，{14{1′b0}}}；assign

＞ dpp_13＝{{19{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[13]}}&d_poly_ex)，

＞ {13{1′b0}}}；assign dpp_12＝{{20{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[12]}}&d_poly_ex)，{12{1′b0}}}；assign

＞ dpp_11＝{{21{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[11]}}&d_poly_ex)，

＞ {11{1′b0}}}；assign dpp_10＝{{22{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[10]}}&d_poly_ex)，{10{1′b0}}}；assign

＞ dpp_9＝{{23{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[9

＞ ]}}&d_poly_ex)，{9{1′b0}}}；assign dpp_8＝{

＞ {24{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[8]}}&

＞d_poly_ex)，{8{1′b0}}}；assign dp_8＝({{32{1′b0}}，d_din_1_ex2}

＞^dp_ex2)^((dpp_15^dpp_14)^dpp_11)^((dpp_13^dpp_12) ^

＞dpp_10)^(dpp_9^dpp_8)；

＞

＞ //Divider -2nd 8-bits

＞ assign d_o[7]＝dp_8[7+32]；

＞ assign d_o[6]＝dp_8[6+32] ^

＞ (dp_8[7+32]&d_p[31])；

＞ assign d_o[5]＝dp_8[5+32] ^

＞ (dp_8[6+32]&d_p[31]) ^

＞ (dp_8[7+32]&d_p_29)；

＞ assign d_o[4]＝dp_8[4+32] ^

＞ (dp_8[7+32]&d_p_28) ^

＞ (dp_8[6+32]&d_p_29) ^

＞ (dp_8[5+32]&d_p[31])；

＞ assign d_o[3]＝dp_8[3+32] ^

＞ (dp_8[4+32]&d_p[31]) ^

＞ (dp_8[5+32]&d_p_29) ^

＞ (dp_8[6+32]&d_p_28) ^

＞ (dp_8[7+32]&d_p_27)；

＞ assign d_o[2]＝dp_8[2+32] ^

＞ (dp_8[3+32]&d_p[31]) ^

＞ (dp_8[4+32]&(d_p[31]^d_p[30])) ^

＞ (dp_8[5+32]&d_p_28) ^

＞ (dp_8[6+32]&d_p_27) ^

＞ (dp_8[7+32]&d_p_26)；

＞ assign d_o[1]＝dp_8[1+32] ^

＞ (dp_8[2+32]&d_p[31]) ^

＞ (dp_8[3+32]&(d_p[31]^d_p[30])) ^

＞ (dp_8[4+32]&d_p_28) ^

＞ (dp_8[5+32]&d_p_27) ^

＞ (dp_8[6+32]&d_p_26) ^

＞ (dp_8[7+32]&(d_p[26]^d_p[29]^(d_p[31]&

＞ d_p[28])^(d_p[31]|d_p[30])))；assign d_o[0]＝dp_8[0+32] ^

＞ (dp_8[1+32]&d_p[31]) ^

＞ (dp_8[2+32]&(d_p[31]^d_p[30])) ^

＞ (dp_8[3+32]&d_p_28) ^

＞ (dp_8[4+32]&d_p_27) ^

＞ (dp_8[5+32]&d_p_26) ^

＞ (dp_8[6+32]&(d_p[26]^d_p[29]^(d_p[31]&

＞ d_p[28])^(d_p[31]|d_p[30])))^(dp_8[7+32]&

＞ d_p[25])^(dp_8[7+32]&d_p[31]&d_p[27]) ^

＞ (dp_8[7+32]&_p[30]&d_p[29]) ^

＞ (dp_8[7+32]&d_p[31])；

＞ assign dpp_7＝{{25{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[7]}}&

＞ d_poly_ex)，{7{1′b0}}}；assign dpp_6＝{{26{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[6]}}&d_poly_ex)，{6{1′b0}}}；assign

＞ dpp_5＝{{27{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[5]}}&d_poly_ex)，

＞ {5{1′b0}}}；assign dpp_4＝{{28{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[4]}}&d_poly_ex)，{4{1′b0}}}；assign

＞ dpp_3＝{{29{1′b0}}，({`AR1DPU__INT_WIDTH{d_o[3]}}&d_poly_ex)，

＞ {3{1′b0}}}；assign dpp_2＝{{20{1′b0}}，

＞ ({`AR1DPU_INT_WIDTH{d_o[2]}}&d_poly_ex)，{2{1′b0}}}；assign

＞ dpp_1＝{{31{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[1]}}&

＞ d_poly_ex)，{1{1′b0}}}；assign dpp_0＝{

＞{32{1′b0}}，({`AR1DPU_INT_WIDTH{d_o[0]}}&d_poly_ex)}；assign dp_0

＞＝((dp_8^dpp_7)^dpp_4)^((dpp_6^dpp_5)^dpp_3)^(dpp_2 ^

＞dpp_1)^dpp_0；

＞

＞ //------------------------

＞ //Divider Wr stage

＞ //------------------------

＞ always (posedge clk)

＞ if(cmd_div_ex2)begin

＞ dout_wr＜＝{dp_ex2[63:48]，d_o[15:0]，dp_0[31:0]}；

＞ end

＞

＞ assign d_rout_wr＝cmd_size_wr[1]？dout_wr[31:0]：(

＞ cmd_size_wr[0]？{{16{1′b0}}，dout_wr[31:16]}：

＞ {{24{1′b0}}，dout_wr[31:24]})；

＞

//----------------------------------------------------

-------

＞//Output

＞

//----------------------------------------------------

-------

＞

＞assign{dout，rout}＝cmd_div_wr？{dout_wr[63:32]，d_rout-wr}：

＞m_out；

图5示出可以用于矢量多项式除法指令的语法。该语法类似于图2中所示出的语法，除了存储分子值和所得到的商值以及余数值的寄存器被矢量寄存器代替之外。分母保持存储在标量寄存器中的标量值，因为将会认识到对于长序列的分子值来说分母商和分母值通常将是常数。这是与用于并行处理要被传输的多个信号数据流的加扰器程序相关联的行为的类型。商多项式和商值形成要被传输的具有比原始的分子值更适合于传输的特性的数据(例如分子值内的长序列恒定位值将被变成更容易传输的商值内位值的交替模式)。本技术的生成商值的多项式除法指令非常适合于供这样的试图加扰要被传输的信号加扰器程序使用。

图6示出其中可将多项式的项的系数存储在寄存器内的两种方式。特别地，最高次项的系数可以被存储在寄存器内的最高有效位位置或最低有效位位置，所述寄存器用于存储表示多项式系数的值。接着可以从该相关的选择端点推断出其他系数。这类似于系数按照高位在前或低位在前的形式存储在寄存器内。

本技术的多项式除法指令提供了与多项式乘法指令结合的优点，这也可以由相同的处理器4支持。在这种情况下，可以添加类似于图1中所示出的多项式除法电路26的附加处理单元以便支持多项式乘法指令。图7示出可以用于这种多项式乘法指令的语法。第一多项式和第二多项式由存储在相应的寄存器r0和r1中的值表示。所得到的积多项式由存储在寄存器r2内的积值表示。积多项式值是第一和第二多项式的长度的两倍，并且因此寄存器r2是存储表示第一和第二多项式的第一和第二值的寄存器的长度的两倍。实际上，寄存器r2可以由两个标准长度寄存器的组合提供。可替换地，寄存器库12可以包括一个或多个双倍宽度寄存器，例如图1中所示出的2N位寄存器14。这样的双倍宽度寄存器通常被提供用来供标准标量算法中的乘法累积指令使用，并且因此可以重复用于这种类型的多项式乘法指令。这些双倍宽度寄存器还可以被用于存储关于先前讨论的多项式除法指令的分子值。在这种情况下，双倍宽度寄存器将代替图2中所示出的寄存器r0和r1，其中单个双倍宽度寄存器存储表示单个寄存器内的分子多项式的所有系数的值。

在下面的说明性C代码中给出包括不同宽度型式和并入了累加的型式的各种形式的多项式乘法指令的运算。该代码还包括多项式除法指令的类似表示。本领域技术人员将会理解这些定义是可以用来生成响应于指定运算的相关联指令而执行这些运算的相关电路的这些指令的动作。

*-------------------------------------------------*

*polynomial multiply long

*------------------------------------------------*/

poly8_t mull_p8(poly8_t x0，poly8_t x1，poly8_t *x2)

{

#ifdef_OPTIMODE_

#pragrna OUT x2

#pragma INTRINSIC

#endif

poly8_t q＝x0，r＝0；

int C，i；

for(i＝0；i＜8；i++)

{

C＝r＞＞7；

r＝r＜＜1；

if(q＞＞7)

{

r＝r^x1；

}

q＝(q＜＜1)|C；

}

*x2＝q；/*(x0*x1)high 8 bits */

return r；/*(x0*x1)low 8 bits */

}

poly16_t mull_p16(poly16_t x0，poly16_t x1，poly16_t *x2)

{

#ifdef_OPTIMODE_

#pragma OUT x2

#pragma INTRINSIC

#endif

poly16_t q＝x0，r＝0；

int C，i；

for(i＝0；i＜16；i++)

{

C＝r＞＞15；

r＝r＜＜1；

if(q＞＞15)

{

r＝r^x1；

}

q＝(q＜＜1)|C；

}

*x2＝q；/*(x0*x1)high 16 bits */

return r；/*(x0*x1)low 16 bits */

}

poly32_t mull_p32(poly32_t x0，poly32_t x1，poly32_t *x2)

{

#ifdef_OPTIMODE_

#pragma OUT x2

#pragma INTRINSIC

#endif

poly32_t q＝x0，r＝0；

int C，i；

for(i＝0；i＜32；i++)

{

C＝r＞＞31；

r＝r＜＜1；

if(q＞＞31)

{

r＝r^x1；

}

q＝(q＜＜1)|C；

}

*x2＝q；/*(x0*x1)high 32 bits */

return r；/*(x0*x1)low 32 bits */

}

/*-------------------------------------------------*

*polynomial multiply accumulate long

*-------------------------------------------------*/

poly8_t mlal_p8(poly8_t x0，poly8_t x1，poly8_t x2，poly8_t x3，poly8_t

*x4)

{

#ifdef_OPTIMODE_

#pragma OUT x4

#pragma INTRINSIC

#endif

poly8_t q＝x2，r＝0；

int C，i；

for(i＝0；i＜8；i++)

{

C＝r＞＞7；

r＝r＜＜1；

if(q＞＞7)

{

r＝r^x3；

}

q＝(q＜＜1)|C；

}

*x4＝q^x1；/*((x1＜＜8)+x0)+(x2*x3)high 8 bits */

return r^x0；/*((x1＜＜8)+x0)+(x2*x3)low 8 bits */

}

poly16_t mlal_p16(poly16_t x0，poly16_t x1，poly 16_t x2，poly 16_t x3，

poly16_t *x4)

{

#ifdef_OPTIMODE_

#pragma OUT x4

#pragma INTRINSIC

#endif

poly16_t q＝x2，r＝0；

int C，i；

for(i＝0；i＜16；i++)

{

C＝r＞＞15；

r＝r＜＜1；

if(q＞＞15)

{

r＝r^x3；

}

q＝(q＜＜1)|C；

}

*x4＝q^x1；/*((x1＜＜16)+x0)+(x2*x3)high 16 bits */

return r^x0；/*((x1＜＜16)+x0)+(x2*x3)low 16 bits */

}

poly32_t mlal_p32(poly32_t x0，poly32_t x1，poly32_t x2，poly32_t x3，

poly32_t *x4)

{

#ifdef_OPTIMODE_

#pragma OUT x4

#pragma INTRINSIC

#endif

poly32_t q＝x2，r＝0；

int C，i；

for(i＝0；i＜32；i++)

{

C＝r＞＞31；

r＝r＜＜1；

if(q＞＞31)

{

r＝r^x3；

}

q＝(q＜＜1)|C；

}

*x4＝q^x1；/*((x1＜＜32)+x0)+(x2*x3)high 32 bits */

return r^x0；/*((x1＜＜32)+x0)+(x2*x3)low 32 bits */

}

/*-----------------------------------------------*

*polynomial long divide

*-----------------------------------------------*/

poly8_t divl_p8(poly8_t x0，poly8_t x1，poly8_t x2，poly8_t *x3)

{

#ifdef_OPTIMODE_

#pragma OUT x3

#pragma INTRINSIC

#endif

poly8_t q＝x0，r＝x1，p＝x2；

int C，i；

for(i＝0；i＜8；i++)

{

C＝r＞＞7；

r＝r＜＜1；

if(C)

{

r＝r^p；

}

if(q＞＞7)

{

r＝r^1；

}

q＝(q＜＜1)|C；

}

*x3＝q；/*((x1＜＜8)+x0)div((1＜＜8)+x2)*/

return r；/*((x1＜＜8)+x0)mod((1＜＜8)+x2)*/

}

poly16_t divl_p16(poly16_t x0，poly16_t x1，poly16_t x2，poly 16_t *x3)

{

#ifdef_OPTIMODE_

#pragma OUT x3

#pragma INTRINSIC

#endif

poly16_t q＝x0，r＝x1，p＝x2；

int C，i；

for(i＝0；i＜16；i++)

{

C＝r＞＞15；

r＝r＜＜1；

if(C)

{

r＝r^p；

}

if(q＞＞15)

{

r＝r^1；

}

q＝(q＜＜1)|C；

}

*x3＝q；/*((x1＜＜16)+x0)div((1＜＜16)+x2)*/

return r；/*((x1＜＜16)+x0)mod((1＜＜16)+x2)*/

}

poly32_t divl_p32(poly32_t x0，poly32_t x1，poly32_t x2，poly32_t *x3)

{

#ifdef_OPTIMODE_

#pragma OUT x3

#pragma INTRINSIC

#endif

poly32_t q＝x0，r＝x1，p＝x2；

int C，i；

for(i＝0；i＜32；i++)

{

C＝r＞＞31；

r＝r＜＜1；

if(C)

{

r＝r^p；

}

if(q＞＞31)

{

r＝r^1；

}

q＝(q＜＜1)|C；

}

*x3＝q；/*((x1＜＜32)+x0)div((1＜＜32)+x2)*/

return r；/*((x1＜＜32)+x0)mod((1＜＜32)+x2)*/

}

尽管上述技术可以由执行包括上面提到的指令的一系列原生(native)指令的硬件执行，但是将会理解在替换实施例中，这样的指令可以在虚拟机环境中执行，其中所述指令对所述虚拟机来说是原生的，但是所述虚拟机由在硬件上执行的具有不同原生指令集的软件实施。该虚拟机环境可以提供模仿完全指令集的执行的完全虚拟机环境或者可以部分(例如仅一些指令，包括本技术的指令)被硬件捕获并且被部分虚拟机模拟。

更具体来说，上述重新布置指令可以被执行为整个或部分虚拟机的原生指令，其中虚拟机连同其下面的结合操作的硬件平台一起来提供上述多项式处理。

Claims

1.一种用于处理数据的装置，包括：

响应于程序指令来生成一个或多个控制信号的指令解码器；

具有多个寄存器的寄存器库；以及

所述指令解码器响应于作为单个指令的多项式除法指令来生成一个或多个控制信号，所述一个或多个控制信号控制所述处理电路至少生成表示用分母多项式去除分子多项式的二元域上的多项式除法的商多项式的商值作为存储在所述多个寄存器之一中的输出，所述分母多项式是由c_ixⁱ(N≥i≥0)的和给出的N次多项式，其中c_(N-1)到c₀表示存储在所述寄存器库的寄存器中的相应位，以及c_N＝1并且没有被存储在所述寄存器中。

2.根据权利要求1所述的装置，其中所述寄存器是N位寄存器。

3.根据权利要求1所述的装置，其中所述寄存器库包括多个N位寄存器。

4.根据前述权利要求中的任一项所述的装置，其中由下述之一来表示多项式：

(i)具有作为M位寄存器的位k的项x^k的系数c_k的所述M位寄存器内的值，其中(M-1)≥k≥0；以及

(ii)具有作为M位寄存器的位(M-1)-k的项x^k的系数c_k的所述M位寄存器内的值，其中(M-1)≥k≥0。

5.根据权利要求3所述的装置，其中所述分子多项式由存储在所述多个N位寄存器的两个寄存器内的2N位分子值表示。

6.根据权利要求1所述的装置，其中所述分子多项式由存储在所述多个寄存器的2N位寄存器内的2N位分子值表示。

7.根据权利要求1所述的装置，其中所述处理电路由所述控制信号控制以生成表示由用所述分母多项式去除所述分子多项式的多项式除法产生的余数多项式的余数值，其中所述控制信号是所述指令解码器响应于所述多项式除法指令生成的。

8.根据权利要求7所述的装置，其中所述余数值是存储在所述多个寄存器的N位寄存器内的N位余数值。

9.根据权利要求1所述的装置，其中所述商值是存储在所述多个寄存器的N位寄存器内的N位商值。

10.根据权利要求1所述的装置，其中所述多项式除法指令是由所述装置执行以使用所生成的商值来对要传输的信号加扰的部分加扰器程序代码。

11.根据权利要求1所述的装置，其中所述寄存器库包括由程序指令而不是所述多项式除法指令使用的多个通用标量寄存器。

12.根据权利要求1所述的装置，其中所述指令解码器响应于多项式乘法指令来生成一个或多个控制信号，所述一个或多个控制信号控制所述处理电路至少生成表示用第二多项式去乘第一多项式的二元域上的多项式乘法的积多项式的积值。

13.根据权利要求1所述的装置，其中所述多项式除法指令是具有作为标量值的分母值和作为矢量值的所述商值以及表示所述分子多项式的分子值的矢量指令。

14.一种处理数据的方法，包括下述步骤：

解码程序指令以生成一个或多个控制信号；

所述解码响应于作为单个指令的多项式除法指令来生成一个或多个控制信号，所述一个或多个控制信号控制至少生成表示用分母多项式去除分子多项式的二元域上的多项式除法的商多项式的商值作为存储在所述多个寄存器之一中的输出，所述分母多项式是由c_ixⁱ(N≥i≥0)的和给出的N次多项式，其中c_(N-1)到c₀表示存储在所述寄存器库的寄存器中的相应位，以及c_N＝1并且没有被存储在所述寄存器中。

15.根据权利要求14所述的方法，其中所述寄存器是N位寄存器。

16.根据权利要求14所述的方法，其中所述寄存器库包括多个N位寄存器。

17.根据权利要求14-16中的任一项所述的方法，其中由下述之一来表示多项式：

18.根据权利要求16所述的方法，其中所述分子多项式由存储在所述多个N位寄存器的两个寄存器内的2N位分子值表示。

19.根据权利要求14所述的方法，其中所述分子多项式由存储在所述多个寄存器的2N位寄存器内的2N位分子值表示。

20.根据权利要求14所述的方法，其中通过解码所述多项式除法指令生成的所述控制信号控制表示由用所述分母多项式去除所述分子多项式的多项式除法产生的余数多项式的余数值的生成。

21.根据权利要求20所述的方法，其中所述余数值是存储在所述多个寄存器的N位寄存器内的N位余数值。

22.根据权利要求14所述的方法，其中所述商值是存储在所述多个寄存器的N位寄存器内的N位商值。

23.根据权利要求14所述的方法，其中所述多项式除法指令是被执行以使用所生成的商值来对要传输的信号加扰的部分加扰器程序代码。

24.根据权利要求14所述的方法，其中所述寄存器库包括由程序指令而不是所述多项式除法指令使用的多个通用标量寄存器。

25.根据权利要求14所述的方法，其中所述解码响应于多项式乘法指令来生成一个或多个控制信号，所述一个或多个控制信号控制至少生成表示用第二多项式去乘第一多项式的二元域上的多项式乘法的积多项式的积值。

26.根据权利要求14所述的方法，其中所述多项式除法指令是具有作为标量值的分母值和作为矢量值的所述商值以及表示所述分子多项式的分子值的矢量指令。