CN1845065A

CN1845065A - Method for processing data width and application thereof

Info

Publication number: CN1845065A
Application number: CN 200510082802
Authority: CN
Inventors: 蒋代林
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Technologies Co Ltd
Priority date: 2005-07-08
Filing date: 2005-07-08
Publication date: 2006-10-11
Anticipated expiration: 2025-07-08
Also published as: CN100454234C

Abstract

The invention discloses a method for treating data width. Wherein, the applied data width is M*N bits, while M is unit data bit width, N is a positive integer not smaller than 1; dividing the applied data into N sections of M bits unit data, while the highest unit data can be negative or non-negative integer, and other unit data are non-negative integer. The invention can improve the calculating speed, and reduce the operation of code.

Description

A kind of method of processing data width and application thereof

Technical field

The present invention relates to field of computer technology, relate in particular to microcomputer data processing.

Background technology

When carrying out data processing in software or among the DSP, can run into used data width and surpass their the actual scopes that can express, such as: software or DSP can only support the data of the wideest 32 bits, but handled data width is 64 bits even wideer, just may run into this situation when verifying the IC design with software or DSP.

When carrying out data processing in software or among the DSP, need come processing data width, to solve the problem that the data width that is run into has surpassed they the actual scopes that can express with a kind of active data method for expressing.

The signed integer that present signed integer with two 32 bits is treated to one 64 bit is an example, manages the method for data width in conjunction with the plus-minus shift operation in the open.

Have the integer of symbol to represent with two's complement in computing machine, most significant digit is a sign bit, and all the other are the data significance bit.The signed integer of above-mentioned 32 bits comes to this, but the data of 64 bits are to represent with the data of two 32 bits, and how to represent then has multiple choices.

The data type of one 64 bit of definition is as follows:

#define?word32?int

typedef?struct?word64{word32?wh32;word32?wl32;}word64;

word64?w64;

The bit wide of integer in different environment or the system (int) is variant, and we suppose that it is 32 bits, and RNTO word32; Defined the new data type word64 of one 64 bit, it is by the data representation of two word32 types, is divided into height two parts, and wh32 is high field, and wl32 is low field; W64 is exactly the data of a word64 type; Wh32 and wl32 are signed number, and w64 is actual to be the number of 63 bits.

Present processing method for expressing is: when w64 is nonnegative number (positive number or zero), wh32 and wl32 are nonnegative number; When w64 was negative, wh32 and wl32 were negative; A kind of special case is when w64 is negative: wh32 is zero, and wl32 is a negative.

It is as follows that the negate of realizing with this method for expressing is counted the code of computing, additive operation, shift right operation or XOR:

A) negate computing:

word64?NEG(word64?x){

word64?z;

z.wh32=-x.wh32;

z.wl32=-x.wl32;

if(((z.wh32<0)&&(z.wl32==0))||(z.wl32==(word32)0x80000000))

If { // operation result is negative then revises to meet the data representation structure

z.wh32=z.wh32+0x1;

z.wl32=z.wl32+(word32)0x80000000;

}else;

return(z);

}

When we will calculate the negative value of new data type word64x of one 64 bit, at first x is converted to by the data representation of two word32 types, be divided into height two parts, wh32 is high field, wl32 is low field; Height two parts difference negate remerges the negative value that draws x then.

B) additive operation:

word64?ADD(word64?x,word64?y){

word64?z;

z.wh32=x.wh32+y.wh32;

z.wl32=x.wl32+y.wl32;

if((x.wl32<0)&&(y.wl32<0)&&(z.wl32>=0))

{

z.wh32=z.wh32-0x1;

z.wl32=z.wl32+(word32)0x80000000;

}

else?if((x.wl32>0)&&(y.wl32>0)&&(z.wl32<0))

{

z.wh32=z.wh32+0x1;

z.wl32=z.wl32+(word32)0x80000000;

}

if((z.wh32>0)&&(z.wl32<0))

{

z.wh32=z.wh32-0x1;

z.wl32=z.wl32+(word32)0x80000000;

}

else?if((z.wh32<0)&&(z.wl32>0))

{

z.wh32=z.wh32+0x1;

z.wl32=z.wl32+(word32)0x80000000;

}

else;

return(z);

}

When we to calculate two 64 bits new data type word64 x and y's and the time, at first x is converted to data representation by two word32 types, be divided into height two parts, wh32 is high field, wl32 is low field, converts y to by two word32 types data representation, is divided into height two parts, wh32 is high field, and wl32 is low field; Height two parts of x, y are sued for peace respectively then, remerge draw x and y and.

C) shift right operation:

word64?SHR(word64?x,short?i){//i<=31

word64?z；

if((x.wh32<0)&&(x.wl32<0))

{

z.wh32=x.wh32-(word32)0x1;

z.wl32=x.wl32+(word32)0x80000000;

}

else?z=x;

z.wl32=(z.wl32>>i)+((z.wh32<<(3l-i))&(word32)0x7fffffff);

z.wh32=(z.wh32>>i);

if((z.wh32<0)&&(z.wl32>=0))

{

z.wh32=z.wh32+(word32)0x1;

z.wl32=z.wl32+(word32)0x80000000;

}

else;

return(z);

}

When the new data type word64 x to 64 bits moves to right, at first x is converted to data representation by two word32 types, be divided into height two parts, wh32 is high field, wl32 is low field; Then x is moved to right, wherein also need middle result is revised.

D) XOR:

word64?XOR(word64?x,word64?y){

word64?z;

if((x.wl32<0)&&(x.wh32==0))x.wh32=-1;

if((y.wl32<0)&&(y.wh32==0))y.wh32=-1;

z.wh32=x.wh32^y.wh32;

z.wl32=x.wl32^y.wl32;

return?z;

}

When we will to the new data type word64 x of two 64 bits and y asks different and the time, at first x is converted to data representation by two word32 types, be divided into height two parts, wh32 is high field, wl32 is low field, converts y to by two word32 types data representation, is divided into height two parts, wh32 is high field, and wl32 is low field; Ask different respectively to height two parts of x, y then and, remerge draw the different of x and y and.

Can find out from above-mentioned code, make a lot of data correction for meeting the data representation structure, code is complicated, and this data processing method has increased code quantity and operation time undoubtedly, has reduced arithmetic speed.

Summary of the invention

The objective of the invention is to propose a kind of method and application thereof of processing data width, can reduce the software code quantity of various computings, improve the software arithmetic speed greatly.

For this reason, the present invention adopts following scheme:

A kind of method of processing data width, the application data width is the M*N bit, wherein M is the unit data bit width, N is not less than 1 positive integer, application data is resolved into the unit data of N section M bit, wherein the unit data of most significant digit can be negative or non-negative integer, and the other unit data are nonnegative integer.

Judgement should be negative integer to the unit data of described most significant digit according to application data, also is non-negative integer.

Described unit data width can be 32 bits.

To the application of this processing data width method, the computing that can be used for carrying out comprises negate computing, additive operation, shift right operation, XOR.

Adopted the present invention, the data structure easy to understand; Reduced the software code quantity of various computings; Improve the software arithmetic speed greatly, improved operation efficiency.

Description of drawings

Fig. 1 is the structural representation of processing data width of the present invention.

Embodiment

Below in conjunction with Figure of description the specific embodiment of the present invention is described.

, can handle as application data with the integer of 64 bits with 32 bit base data.As shown in Figure 1, just can find intuitively from the data of two's complement: for the integer of 64 bits, no matter it is negative or nonnegative number (integer or zero), all can be separated into two parts from the centre, separately, high field partly is one, and can bear can non-negative integer, and low field then is a nonnegative number.

A) negate computing:

word64?NEG(word64?x){

x.wh32=-x.wh32;

x.wl32=(-x.wl32)&(word32)0x7fffffff;

if(x.wl32!=0)

x.wh32--;

}else;

return?x;

}

Compare with former algorithm, need the low field wl32 that has only data of correction, and correction conditions is simplified greatly.

B) additive operation:

word64?ADD(word64?x,word64?y){

x.wh32+=y.wh32;

x.wl32+=y.wl32;

if(x.wl32<0)

{

x.wl32&=(word32)0x7fffffff;

x.wh32++;

}else;

return?x;

}

Compare with former algorithm, correction conditions is greatly simplified, and the code computing is little a lot.

C) shift right operation:

word64?SHR(word64?x,short?i){//i<=31

x.wl32=((x.wl32>>i)+(x.wh32<<(31-i))&(word32)0x7fffffff);

x.wh32=(x.wh32>>i);

return?x;

}

Compare with former algorithm, saved correction conditions, lacked many numerous and diverse plus and minus calculations.

D) XOR:

word64?XOR(word64?x,word64?y){

word64?z;

z.wh32=x.wh32^y.wh32;

z.wl32=x.wl32^y.wl32;

return?z;

}

Compare with former algorithm, saved correction conditions, only need to height two parts of x, y ask different respectively and, remerge draw the different of x and y with.

Compare with the operation part of prior art, code clearly of the present invention is simple a lot, lacked many for meeting the correction that data structure is carried out, thereby improved the arithmetic speed of code, reduced operand.When the exclusive disjunction amount is big when the real-time of software is had relatively high expectations,, effectively beyond doubt with this data representation method.

This method is applicable to wideer data representation, such as the data of representing 128 bits with 32 bit numbers, the highest field can non-negative integer for bearing, and other field is non-negative integer, the realization of various operation parts is to above-mentioned similar, and the developed width of 128 Bit datas is 125 bits.

Therefore represent that with the M bit number N*M Bit data can adopt this method, the developed width of data is N* (M-1)+1, and wherein M is the unit data bit width, and N is not less than 1 positive integer.

The above; only for the preferable embodiment of the present invention, but protection scope of the present invention is not limited thereto, and anyly is familiar with the people of this technology in the disclosed technical scope of the present invention; the variation that can expect easily or replacement all should be encompassed within protection scope of the present invention.Therefore, protection scope of the present invention should be as the criterion with the protection domain of claim.

Claims

1, a kind of method of processing data width, the application data width is the M*N bit, wherein M is the unit data bit width, N is not less than 1 positive integer, it is characterized in that: the unit data that application data is resolved into N section M bit, wherein the unit data of most significant digit can be negative or non-negative integer, and the other unit data are nonnegative integer.

2, the method for processing data width as claimed in claim 1 is characterized in that: judgement should be negative integer to the unit data of described most significant digit according to application data, also is non-negative integer.

3, the method for processing data width as claimed in claim 1 or 2 is characterized in that: described unit data width can be 32 bits.

4, the application of processing data width method as claimed in claim 1 is characterized in that: can use the computing that the method for described processing data width carries out and comprise negate computing, additive operation, shift right operation, XOR.