Visual C++, GCC, Assembly SSE

[gabriel]

Olá pessoal, continuo com minhas experiências no desenvolvimento de
jogos, e agora meti na venta de usar SSE para otimizar minhas
operações com vetores até ai sem problemas.
Mas eu quero que meu código seja compilado no GCC e no Visual C++,
só que um usa a syntax Intel e a outra AT&T, e eu pretendia usar
inline asm. o que poderia fazer? matar o Visual C++ eu não gostaria pq
é uma bela IDE, mas a plataforma base é Linux. tem algumas dicas?

Obrigado.

http://www.neilkemp.us/v4/articles/sse_tutorial/sse_tutorial.html
http://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html#s1

[Rodrigo Kumpera]

2009/6/18 gabriel <newbi...@gmail.com>

Você pode usar os intrisincs para SSE que funciona em ambos compilados. Porém com o GCC
você precisa ficar verificando o código gerado pois ele faz um péssimo serviço na alocação de registradores.

Tem a opção de programar usando macros p/ disfarçar o asm. Da trabalho pacas e pode ficar ilegível,
mas pode compensar, dependendo do caso.

Ou, por fim, você pode usar o GCC com todos SOs e desistir do VC++. E se precisar de um compilador
melhor, só usar o ICC.

[gabriel]

Abandonar o VC++ até que vai, namoro o ICC a um tempo mas não pretendo
usar, e tem umas libs que são compiladas no GCC (Open Dynamics Engine)
OpenGL SDL, me encontro agora embrenhado na internet vendo se é
possivel compilar o que eu seja .asm no NASM ou GAS e depois usar como
extern ou algo do tipo.


On 18 jun, 09:29, Rodrigo Kumpera <kump...@gmail.com> wrote:
> 2009/6/18 gabriel <newbie....@gmail.com>

[Blabos de Blebe]

as ?

2009/6/18 gabriel <newbi...@gmail.com>:

[gabriel]

é mais ou menos isso que eu preciso.

http://paginas.fe.up.pt/~jcard/ensino/LabC/docs/C_Assembler.pdf

[André Tupinambá]

Gabriel,

Você não precisa utilizar assembly para usar os comandos SSE, existem
intrisincs que podem ser utilizados e são padrões para ambos os
compiladores.

Por exemplo, ao invés de utilizar em assembly:

PAND xmm0, xmm1

você pode fazer o mesmo com intrisinc:

_mm_and_si128( var1, var2 );

Sacou?

Olhe na documentação oficial da Intel em
http://www.intel.com/products/processor/manuals/index.htm os
documentos Intel® 64 and IA-32 Architectures Software Developer's
Manual Volume 2A e 2B. Todas as instruções SSE possuem intrisincs
equivalentes para serem utilizadas em C. No final do volume 2B existe
uma tabela com todos esses intrincs.

[]'s
André Tupinambá

2009/6/18 gabriel <newbi...@gmail.com>:

[gabriel]

hum...
interessante já baixei a documentação
mas uma dúvida isso tb val p/ o GCC ou só p/ o ICC?

On 18 jun, 10:20, André Tupinambá <andre...@gmail.com> wrote:
> Gabriel,
>
> Você não precisa utilizar assembly para usar os comandos SSE, existem
> intrisincs que podem ser utilizados e são padrões para ambos os
> compiladores.
>
> Por exemplo, ao invés de utilizar em assembly:
>
> PAND xmm0, xmm1
>
> você pode fazer o mesmo com intrisinc:
>
> _mm_and_si128( var1, var2 );
>
> Sacou?
>
> Olhe na documentação oficial da Intel emhttp://www.intel.com/products/processor/manuals/index.htmos
> documentos Intel® 64 and IA-32 Architectures Software Developer's
> Manual Volume 2A e 2B. Todas as instruções SSE possuem intrisincs
> equivalentes para serem utilizadas em C. No final do volume 2B existe
> uma tabela com todos esses intrincs.
>
> []'s
> André Tupinambá
>

> 2009/6/18 gabriel <newbie....@gmail.com>:

[gabriel]

Achei mais algumas coisas


http://www.tuleriit.ee/progs/rexample.php

Obrigado pela ajuda.

[André Tupinambá]

Isso vale para Visual C++, GCC, ICC e possivelmente para outros
compiladores também.

Aconselho procurar um livro sobre o assunto, eu estudei com um de
otimização [1] da Intel, mas existe um somente sobre as instruções
vetoriais [2].

[]'s
André Tupinambá

[1] http://www.intel.com/intelpress/sum_swcb2.htm
[2] http://www.intel.com/intelpress/sum_vmmx.htm

2009/6/18 gabriel <newbi...@gmail.com>:

[Paulo Rogério Panhoto]

você não pode fazer módulos específicos (algo como vetores-vc.cpp e vetores-gcc.cpp), cada um no seu respectivo makefile (ou projeto)? Sei que, por um lado, isso dificulta a manutenção mas, por outro, isso também pode ajudar no "fine tuning".

[Rodrigo Kumpera]

Não ajuda nenhum pouco no "fine tunning" uma vez que o código vai ser basicamente o mesmo independente do
compilador.

2009/6/18 Paulo Rogério Panhoto <pa...@voicetechnology.com.br>

[gabriel]

Creio que isso seria o melhor pq eu tenho coisas como
multiplicação de matrizes que o intrisincs não iria dar conta.

vou meditar um pouco sobre o assunto.


On 18 jun, 15:00, Paulo Rogério Panhoto <pa...@voicetechnology.com.br>
wrote:

> você não pode fazer módulos específicos (algo como vetores-vc.cpp e vetores-gcc.cpp), cada um no seu respectivo makefile (ou projeto)? Sei que, por um lado, isso dificulta a manutenção mas, por outro, isso também pode ajudar no "fine tuning".
> Rodrigo Kumpera wrote:2009/6/18 gabriel<newbi...@gmail.com>
> Olá pessoal, continuo com minhas experiências no desenvolvimento de
> jogos, e agora meti na venta de usar SSE para otimizar minhas
> operações com vetores até ai sem problemas.
> Mas eu quero que meu código seja compilado no GCC e no Visual C++,
> só que um usa a syntax Intel e a outra AT&T, e eu pretendia usar
> inline asm. o que poderia fazer? matar o Visual C++ eu não gostaria pq
> é uma bela IDE, mas a plataforma base é Linux. tem algumas dicas?

> Obrigado.http://www.neilkemp.us/v4/articles/sse_tutorial/sse_tutorial.htmlhttp://www.ibiblio.org/gferg/ldp/GCC-Inline-Assembly-HOWTO.html#s1

[Rodrigo Kumpera]

Não iria dar conta porque?

2009/6/18 gabriel <newbi...@gmail.com>

[gabriel]

// MatrixMultiply3 -- a C++/ASM version of MatrixMultiply2, which
takes
// advantage of Intel's SSE instructions. This version requires that
// M be in column-major order.
//
// Performance: 57 cycles/vector
void MatrixMultiply3(Matrix4f &m, Vector4f *vin, Vector4f *vout)
{
// Get a pointer to the elements of m
float *row0 = m.Ref();

__asm {
mov esi, vin
mov edi, vout

// load columns of matrix into xmm4-7
mov edx, row0
movups xmm4, [edx]
movups xmm5, [edx+0x10]
movups xmm6, [edx+0x20]
movups xmm7, [edx+0x30]

// load v into xmm0.
movups xmm0, [esi]

// we'll store the final result in xmm2; initialize it
// to zero
xorps xmm2, xmm2

// broadcast x into xmm1, multiply it by the first
// column of the matrix (xmm4), and add it to the total
movups xmm1, xmm0
shufps xmm1, xmm1, 0x00
mulps xmm1, xmm4
addps xmm2, xmm1

// repeat the process for y, z and w
movups xmm1, xmm0
shufps xmm1, xmm1, 0x55
mulps xmm1, xmm5
addps xmm2, xmm1
movups xmm1, xmm0
shufps xmm1, xmm1, 0xAA
mulps xmm1, xmm6
addps xmm2, xmm1
movups xmm1, xmm0
shufps xmm1, xmm1, 0xFF
mulps xmm1, xmm7
addps xmm2, xmm1

// write the results to vout
movups [edi], xmm2
}
}

*****************

só achei que não daria pra fazer ese tipo de cosia com intrisincs

ai eu pensei em fazer tudo isso com o (g)as, e linkar
mais ai tem o maldito alinhamento, não sei como iria passar uma struct
typo {float x, float y,float z, float w};
talvez eu pudesse passar um ponteiro, de qq jeito vou ter que me
engraçar com uns livros de asm pra ver como vou fazer isso.

On 18 jun, 15:20, Rodrigo Kumpera <kump...@gmail.com> wrote:
> Não iria dar conta porque?
>

> 2009/6/18 gabriel <newbie....@gmail.com>

>
>
>
> > Creio que isso seria o melhor pq eu tenho coisas como
> > multiplicação de matrizes que o intrisincs não iria dar conta.
>
> > vou meditar um pouco sobre o assunto.
>
> > On 18 jun, 15:00, Paulo Rogério Panhoto <pa...@voicetechnology.com.br>
> > wrote:
> > > você não pode fazer módulos específicos (algo como vetores-vc.cpp e
> > vetores-gcc.cpp), cada um no seu respectivo makefile (ou projeto)? Sei que,
> > por um lado, isso dificulta a manutenção mas, por outro, isso também pode
> > ajudar no "fine tuning".

> > > Rodrigo Kumpera wrote:2009/6/18 gabriel<newbie....@gmail.com>

> > > Olá pessoal, continuo com minhas experiências no desenvolvimento de
> > > jogos, e agora meti na venta de usar SSE para otimizar minhas
> > > operações com vetores até ai sem problemas.
> > > Mas eu quero que meu código seja compilado no GCC e no Visual C++,
> > > só que um usa a syntax Intel e a outra AT&T, e eu pretendia usar
> > > inline asm. o que poderia fazer? matar o Visual C++ eu não gostaria pq
> > > é uma bela IDE, mas a plataforma base é Linux. tem algumas dicas?
> > > Obrigado.

> >http://www.neilkemp.us/v4/articles/sse_tutorial/sse_tutorial.htmlhttp...

[gabriel]

tem varias maneiras de se fazer na verdade.

tem que ver qual é a melhor pro meu caso.

[André Tupinambá]

Eu aposto com você que não só dá pra fazer esse código com intrisincs,
como é capaz de ficar até mais rápido do que seu assembly feito na
mão.

Quando se usa intrisincs, o compilador faz a escolha dos registradores
e reordena as instruções para melhorar o desempenho. Além disso, o
mesmo fonte gera binários diferentes para 32 e 64bits, aproveitando o
maior número de registradores deste.

E depois de tudo, colocar intrisincs tem a vantagem de deixar o código
um pouco mais amigável ao desenvolvedor.

[]'s
André Tupinambá

2009/6/18 gabriel <newbi...@gmail.com>:

[Blabos de Blebe]

http://savannah.nongnu.org/projects/pgubook/

2009/6/18 gabriel <newbi...@gmail.com>:

[gabriel]

vlw Blabos.

Os barbudos da GNU não tinhão como complicar mais o inline assembly do
GCC, parece mais facil entender aramaico.

vlw pela ajuda pessoal, to fazendo alguns testes com o vc++ to sendo
bem sucedido.


On 18 jun, 17:46, Blabos de Blebe <bla...@gmail.com> wrote:
> http://savannah.nongnu.org/projects/pgubook/
>
> 2009/6/18 gabriel <newbie....@gmail.com>:

[Rodrigo Kumpera]

Eles copiaram o formato da AT&T.

2009/6/19 gabriel <newbi...@gmail.com>

[gabriel]

o lance dos registradores que é estranho.

On 19 jun, 12:13, Rodrigo Kumpera <kump...@gmail.com> wrote:
> Eles copiaram o formato da AT&T.
>

> 2009/6/19 gabriel <newbie....@gmail.com>

[Ziviani]

Se a sintaxe AT&T te incomoda você pode usar a seguinte diretiva pra usar sintaxe Intel. É útil se você já tem experiência com Nasm e afins, mas não sei se tem alguma restrição fazendo isso. Vale uma pesquisada.

__asm__(".intel_syntax noprefix");

http://stackoverflow.com/questions/549347/how-to-use-address-constants-in-gcc-x86-inline-assembly

2009/6/19 gabriel <newbi...@gmail.com>

--
José Ricardo Ziviani

[gabriel]

andei vendo como éssa coisa toda funciona
adição subtração multiplicação de vetores foi tranquilo
ai pensei bom vamos começar a ver como eu vou fazer com a minhas
matrizes ai
fiz o seguinte teste

typedef struct
{
float x;
float y;
float z;
float w;
}vec4f;


vec4f addvec(vec4f &a,vec4f &b)
{
vec4f v;
__asm
{
MOV EAX, a
MOV EBX, b
MOVUPS XMM0, [EAX]
MOVUPS XMM1, [EBX]
ADDPS XMM0, XMM1
MOVUPS [v], XMM0
}

return v;

}

vec4f subvec(vec4f &a, vec4f &b)
{
vec4f v;
__asm
{
MOV EAX, a;
MOV EBX, b;
MOVUPS XMM0, [EAX]
MOVUPS XMM1, [EBX]
SUBPS XMM0, XMM1
MOVUPS [v], XMM0
}
return v;

}
vec4f mulvec(vec4f &a,vec4f &b)
{
vec4f v;
__asm
{
MOV EAX, a
MOV EBX, b
MOVUPS XMM0, [EAX]
MOVUPS XMM1, [EBX]
MULPS XMM0, XMM1
MOVUPS [v], XMM0
};

return v;

}

vec4f testX(float *matrix)
{
vec4f v;
__asm{
MOV EAX, matrix
MOVUPS XMM0, [EAX]
MOVUPS [v], XMM0
};

return v;
}

vec4f testY(float *matrix)
{
vec4f v;

__asm{
MOV EDX, matrix
MOVUPS XMM0, [EDX+0x10]
MOVUPS [v], XMM0
};

return v;
}

vec4f testZ(float *matrix)
{
vec4f v;

__asm{
MOV EDX, matrix
MOVUPS XMM0, [EDX+0x20]
MOVUPS [v], XMM0
};

return v;
}

vec4f testW(float *matrix)
{
vec4f v;

__asm{
MOV EDX, matrix
MOVUPS XMM0, [EDX+0x30]
MOVUPS [v], XMM0
};

return v;
}

int _tmain(int argc, _TCHAR* argv[])
{
float matrix[16] = {1.0f,0,0,0,
0,1.0f,0,0,
0,0,1.0f,0,
0,0,0,1.0f};
vec4f v1,v2,v3,v4;

v1 = testX(matrix);
v2 = testY(matrix);
v3 = testZ(matrix);
v4 = testW(matrix);

}

v1 = {1.0f,0.0f,0.0f,0.0f};
v2 = {0.0f,1.0f,0.0f,0.0f};
v3 = {0.0f,0.0f,1.0f,0.0f};
v4 = {0.0f,0.0f,0.0f,1.0f};

isso foi só um teste pra ver como funciona, agora vou fazer as
multiplicações de matrizes e tals,
vi um script em perl que converte nasm p/ c inline, ai com makefiles
config.h e um arquivo pro GCC e outro VC++
minha vida fica resolvida.

tenho um código de rasterização 3D em C puro, vou ver c migro o mesmo.

mais bom obrigado pela ajuda.

ps: é má idéia postar o progresso pode ser que ajude mais alguém.

On 19 jun, 13:25, Ziviani <jrzivi...@gmail.com> wrote:
> Se a sintaxe AT&T te incomoda você pode usar a seguinte diretiva pra usar
> sintaxe Intel. É útil se você já tem experiência com Nasm e afins, mas não
> sei se tem alguma restrição fazendo isso. Vale uma pesquisada.
>
> __asm__(".intel_syntax noprefix");
>

> http://stackoverflow.com/questions/549347/how-to-use-address-constant...
>
> 2009/6/19 gabriel <newbie....@gmail.com>

[gabriel]

postei um tópico sobre o assunto, não que as técnicas utilizadas sejão
as mais eficientes mais serviu como estudo.
mais uma vez agradeço a todos.

http://newbie-x11.blogspot.com/2009/06/operacoes-com-vetor-usando-sse.html