__mm_mullo_pi16() intrinsic

Question

0.00/5 (No votes)

See more:

the mullo instruction does seem to give good result;expected 6,000,000 results.what is the proper use of this instruction?

C#

#include "stdafx.h"
#include <mmintrin.h>

int _tmain(int argc, _TCHAR* argv[])
{
    short B[4]={2000,2000,2000,2000};
    short C[4]={3000,3000,3000,3000};
__m64*b =(__m64*)B;
__m64*c =(__m64*)C;
    __m64 r0,r1;
    r0 =_mm_mullo_pi16(*b,*c);
    r1 =_mm_add_pi16(*b,*c);

    return 0;
}

Posted 3-Oct-10 5:13am

SMART LUBOBYA

Updated 3-Oct-10 5:14am

v2

Add a Solution

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Charles Keepax · Accepted Answer · 2010-10-04T03:55:00

Solution 1

Are you by any chance getting 36224 as a result? _mm_mullo_pi16 only returns the lower 16 bits of the result. Presumably you should use a _mm_mulhi_pi16 as well to get the whole 32-bit result.

See MSDN[^], for more.

Charles Keepax

Posted 4-Oct-10 3:55am

Charles Keepax

Comments

SMART LUBOBYA 5-Oct-10 8:07am

yes, with 'mullo' i get 36224 and with 'mulhi', i get 91. more confusing. 2000x3000=6,000,000 for each array pair multiplication. kindly, help.

Charles Keepax 5-Oct-10 9:19am

That would be about right, you need to stick them together to get your answer. So 36224 in hex is 0x8D80 and 91 in hex is 0x5B. Shift the hi result by 16 bits then AND them together and you will get 0x5B8D80, which is hex for 6000000.

SMART LUBOBYA 7-Oct-10 4:00am

i tried to follow your suggested steps above. i still need help. here is what i tried:
#include #Quote#stdafx.h#Quote#
#include <mmintrin.h>

int _tmain(int argc, _TCHAR* argv[])
{
short B[4]={2000,2000,2000,2000};
short C[4]={3000,3000,3000,3000};
__m64*b =(__m64*)B;
__m64*c =(__m64*)C;
__m64 r0,r1,r2,r3,r4;
r0 =_mm_mullo_pi16(*b,*c);
r1 =_mm_mulhi_pi16(*b,*c);
r2 =_mm_slli_pi16(r1,15);
r3 =_mm_and_si64(r2,r0);
r4 =_mm_add_pi16(*b,*c);
_mm_empty();
return 0;

}

SMART LUBOBYA 7-Oct-10 4:01am

which shift should i use?

Charles Keepax 7-Oct-10 4:27am

Your variables r0-r4 are effectively arrays of 4 16-bit numbers; a 16-bit number can only be 0 to 65536 or -32768 to 32767 since you are using signed variables. 6,000,000 is too large to store in a 16-bit number, thus you will need to extract it into a 32-bit number. The following code (assuming int is 32-bit on your system) does this with the first number however it is almost certainly a poor way to use the MMX extensions, but the best way to use them would depend rather heavily on context.

unsigned short B[4]={2000,2000,2000,2000};
unsigned short C[4]={3000,3000,3000,3000};
unsigned short D[4]={0,0,0,0};
unsigned short E[4]={0,0,0,0};
__m64*b =(__m64*)B;
__m64*c =(__m64*)C;
__m64*d =(__m64*)D;
__m64*e =(__m64*)E;

*d =_mm_mullo_pi16(*b,*c);
*e =_mm_mulhi_pi16(*b,*c);

int temp = E[0];
temp = (temp<<16) | D[0];