Erro no programa(A2044 caracter invalid)

[muttley]

Oi pessoal, estou com um problema no meu programa.
O programa consiste em fazer a leitura de matrizes e depois fazer a multiplicação delas de duas formas, uma em linguagem C normal e outra usando a função inline do assembly.

Eu fiz o programa normal, mas está dando esse erro

1>------ Build started: Project: Project, Configuration: Debug Win32 ------
1>Assembling...
1> Assembling: ..\..\..\..\..\irvine\examples\ch03\AddSub.asm
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(1 ) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(2 ) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(3 ) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(4 ) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(5 ) : error A2044:invalid character in file
.
.
.
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(9 5) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(9 6) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(9 7) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(9 8) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(9 9) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(1 00) : error A2044:invalid character in file
1>..\..\..\..\..\irvine\examples\ch03\AddSub.asm(1 01) : fatal error A1012:error count exceeds 100; stopping assembly
1>Project : error PRJ0019: A tool returned an error code from "Assembling..."
1>Build log was saved at "file://c:\Users\muttley\Desktop\Projetos ARQ 2\Project_sample\Debug\BuildLog.htm"
1>Project - 1 error(s), 0 warning(s)
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========



nao sei o q fazer...

o código do programa é este, por favor, se alguém puder compilar ele aí e ver se dá o mesmo erro..
estou usando o Visual Studio C++ 2088 Express Edition

Obrigado!

#include "stdafx.h"
#include
#include
#include

using namespace std;
using namespace System;

#define cpuid __asm __emit 0fh __asm __emit 0a2h
#define rdtsc __asm __emit 0fh __asm __emit 031h

int main()
{
//Parte da linguagem C sem uso de assembly
//Declarando as matrizes
//1
int mA1[4][4];
int mB1[4][4];
int mC1[4][4];

//2
int mA2[16][32];
int mB2[32][32];
int mC2[16][32];

//3
int mA3[80][80];
int mB3[80][120];
int mC3[80][80];

//4
int mA4[360][140];
int mB4[140][360];
int mC4[360][140];

//Variáveis usadas para controle
int i;
int j;
int k;
int soma;

//Variáveis usadas para contagem dos ciclos de clock
unsigned ciclo0, totalciclos, dif1, dif2, dif3, dif4, conv1, conv2, conv3, conv4, ganho1, ganho2, ganho3, ganho4;

//Gerando as matrizes com valores randômico entre 0 e 999 matriz A1 e matriz B1
for(i=0;i<4;i++)
for(j=0;j<4;j++)
mB1[i][j]=rand()%1000;

//matriz A2
for(i=0;i<20;i++)
for(j=0;j<16;j++)
mA2[i][j]=rand()%1000;

//matriz B2
for(i=0;i<30;i++)
for(j=0;j<16;j++)
mB2[i][j]=rand()%1000;

//matriz A3
for(i=0;i<100;i++)
for(j=0;j<60;j++)
mA3[i][j]=rand()%1000;

//matriz B3
for(i=0;i<100;i++)
for(j=0;j<60;j++)
mB3[i][j]=rand()%1000;

//matriz A4
for(i=0;i<300;i++)
for(j=0;j<120;j++)
mA4[i][j]=rand()%1000;

//matriz B4
for(i=0;i<360;i++)
for(j=0;j<120;j++)
mB4[i][j]=rand()%1000;

//Multiplicações das matrizes e mostra na tela o total de ciclos
//mC1 = mA1*mB1
ciclo0=0;
totalciclos=0;
__asm { //Contagem dos ciclos de clock para análise de desempenho
CPUID
RDTSC
mov ciclo0, eax
}
//Multiplicando as matrizes
for(i=0;i<4;i++)
for(j=0;j<4;j++) {
soma = 0;
for(k=0;k<4;k++)
soma += mA1[i][k] * mB1[j][k];
mC1[i][j] = soma;
}
__asm {
CPUID
RDTSC
sub eax, ciclo0
mov totalciclos, eax //move para totalciclos o número de ciclos feitos
}
dif1 = totalciclos;
conv1 = totalciclos;
printf("Multiplicacao das matrizes sem assembly 1\n");
pintf("Total de ciclos: %d\n", totalciclos);

//mC2 = mA2*mB2
ciclo0=0;
totalciclos=0;
__asm {
CPUID
RDTSC
mov ciclo0, eax
}
for(i=0;i<20;i++)
for(j=0;j<30;j++) {
soma = 0;
for(k=0;k<16;k++)
soma += mA2[i][k]*mB2[j][k];
mC2[i][j] = soma;
}
__asm {
CPUID
RDTSC
sub eax, ciclo0
mov totalciclos, eax
}
dif2 = totalciclos;
conv2 = totalciclos;
printf("Multiplicacao das matrizes sem assembly 2\n");
printf("Total de ciclos: %d\n", totalciclos);

//mC3 = mA3*mB3
ciclo0=0;
totalciclos=0;
__asm {
CPUID
RDTSC
mov ciclo0, eax
}
for(i=0;i<100;i++)
for(j=0;j<100;j++) {
soma = 0;
for(k=0;k<60;k++)
soma += mA3[i][k]*mB3[j][k];
mC3[i][j] = soma;
}
__asm {
CPUID
RDTSC
sub eax, ciclo0
mov totalciclos, eax
}
dif3 = totalciclos;
conv3 = totalciclos;
printf("Multiplicacao das matrizes sem assembly 3\n");
printf("Total de ciclos: %d\n",totalciclos);

//mC4 = mA4*mB4
ciclo0=0;
totalciclos=0;
__asm {
CPUID
RDTSC
mov ciclo0, eax
}
for(i=0;i<300;i++)
for(j=0;j<360;j++) {
soma = 0;
for(k=0;k<120;k++)
soma += mA4[i][k]*mB4[j][k];
mC4[i][j] = soma;
}
__asm {
CPUID
RDTSC
sub eax, ciclo0
mov totalciclos, eax
}
dif4 = totalciclos;
conv4 = totalciclos;
printf("Multiplicacao das matrizes sem assembly 4\n");
printf("Total de ciclos: %d\n",totalciclos);
//Fim da linguagem C.

//Início da linguagem C usando instruções assembly "inline".
//Declaração dos ponteiros que serão utilizados para as matrizes
int *pt1;
int *pt2;
int *pt3;

//Apontando os ponteiros para o início da matriz 1 e gera a multiplicação
pt1 = &mA1[0][0];
pt2 = &mB1[0][0];
pt3 = &mC1[0][0];

ciclo0=0;
totalciclos=0;
__asm { //Contagem dos ciclos de clock para análise de desempenho
CPUID
RDTSC
mov ciclo0, eax
mov esi,pt1
mov edx,pt3
mov ecx,4
L1:
push ecx
mov ecx,4
mov edi,pt2
//Empacota os valores para poder realizar todas as multiplicações simultâneamente (SIMD)
L2:
movups xmm3,[esi] //Move números de ponto flutuante com precisão simples empacotados
cvtdq2ps xmm1,xmm3 //Converte 4 inteiros doublewords empacotados de xmm3/m128 para
//4 números ponto flutuante com precisão simples "empacotados" em xmm1
movups xmm4,[edi]
cvtdq2ps xmm2,xmm4
//Multiplica os valores
mulps xmm1,xmm2 //Multiplica números de ponto flutuante com precisão simples
//empacotados em xmm2/mem por xmm1
cvtps2dq xmm0,xmm1
;Desempacota os valores multiplicados
movd eax,xmm0 //Copia 32 bits de xmm0 para eax
shufps xmm0,xmm0,229 //Embaralha escalares paralelos
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,230
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,231
movd ebx,xmm0
add eax,ebx
mov [edx],eax
add edx,4
add edi,16
loop L2
pop ecx
add esi,16
loop L1
//Contagem dos ciclos de clock para análise de desempenho
CPUID
RDTSC
sub eax, ciclo0
mov totalciclos, eax
}
dif1 = dif1 - totalciclos;
printf("Multiplicacao das matrizes com assembly 1\n");
printf("Total de ciclos: %d\n", totalciclos);

//Apontando os ponteiros para o início da matriz 2 e gera a multiplicação
pt1=&mA2[0][0];
pt2=&mB2[0][0];
pt3=&mC2[0][0];

ciclo0 = 0;
totalciclos = 0;
__asm { //Contagem dos ciclos de clock para análise de desempenho
CPUID
RDTSC
mov ciclo0, eax
mov edx,pt3
mov esi,pt1
mov edi,pt2
mov ecx,20
L3:
push ecx
mov ecx, 30
L4:
xor eax,eax
push ecx
mov ecx,4
//Empacota os valores para poder realizar as quatro multiplicações simultâneamente (SIMD)
L5:
movups xmm3,[esi]
cvtdq2ps xmm1,xmm3
movups xmm4,[edi]
cvtdq2ps xmm2,xmm4
//Multiplica os valores
mulps xmm1,xmm2
cvtps2dq xmm0,xmm1
//Desempacota os valores multiplicados
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,229
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,230
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,231
movd ebx,xmm0
add eax,ebx
add esi,16
add edi,16
loop L5
pop ecx
mov [edx],eax
add edx,4
mov esi,pt1
loop L4
pop ecx
mov eax, pt1
add eax, 64
mov pt1,eax
mov edi, pt2
loop L3
//Contagem dos ciclos de clock para análise de desempenho
CPUID
RDTSC
sub eax, ciclo0
mov totalciclos, eax
}
dif2 = dif2 - totalciclos;
printf("Multiplicacao das matrizes com assembly 2\n");
printf("Total de ciclos: %d\n",totalciclos);

//Apontando os ponteiros para o início da matriz 3 e gera a multiplicação
pt1=&mA3[0][0];
pt2=&mB3[0][0];
pt3=&mC3[0][0];

ciclo0 = 0;
totalciclos = 0;
__asm { //Contagem dos ciclos de clock para análise de desempenho
CPUID
RDTSC
mov ciclo0, eax
mov edx,pt3
mov esi,pt1
mov edi,pt2
mov ecx, 100
L6:
push ecx
mov ecx, 100
L7:
xor eax,eax
push ecx
mov ecx,15
//Empacota os valores para poder realizar as quatro multiplicações simultâneamente (SIMD)
L8:
movups xmm3,[esi]
cvtdq2ps xmm1,xmm3
movups xmm4,[edi]
cvtdq2ps xmm2,xmm4
//Multiplica os valores
mulps xmm1,xmm2
cvtps2dq xmm0,xmm1
//Desempacota os valores multiplicados
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,229
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,230
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,231
movd ebx,xmm0
add eax,ebx
add esi,16
add edi,16
loop L8
pop ecx
mov [edx],eax
add edx,4
mov esi,pt1
loop L7
pop ecx
mov eax, pt1
add eax, 240
mov pt1,eax
mov edi, pt2
loop L6
//Contagem dos ciclos de clock para análise de desempenho
CPUID
RDTSC
sub eax, ciclo0
mov totalciclos, eax
}
dif3 = dif3 - totalciclos;
printf("Multiplicacao das matrizes com assembly 3\n");
printf("Total de ciclos: %d\n",totalciclos);

//Apontando os ponteiros para o início da matriz 4 e gera a multiplicação
pt1=&mA4[0][0];
pt2=&mB4[0][0];
pt3=&mC4[0][0];

ciclo0 = 0;
totalciclos = 0;
__asm { //Contagem dos ciclos de clock para análise de desempenho
CPUID
RDTSC
mov ciclo0, eax
mov edx,pt3
mov esi,pt1
mov edi,pt2
mov ecx,300
L9:
push ecx
mov ecx, 360
L10:
xor eax,eax
push ecx
mov ecx, 30
//"Empacota" os valores para poder realizar as quatro multiplicações simultâneamente (SIMD)
L11:
movups xmm3,[esi]
cvtdq2ps xmm1,xmm3
movups xmm4,[edi]
cvtdq2ps xmm2,xmm4
//Multiplica os valores
mulps xmm1,xmm2
cvtps2dq xmm0,xmm1
//"Desempacota" os valores multiplicados
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,229
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,230
movd ebx,xmm0
add eax,ebx
shufps xmm0,xmm0,231
movd ebx,xmm0
add eax,ebx
add esi,16
add edi,16
loop L11
pop ecx
mov [edx],eax
add edx,4
mov esi,pt1
loop L10
pop ecx
mov eax, pt1
add eax, 480
mov pt1,eax
mov edi, pt2
loop L9
//Contagem dos ciclos de clock para análise de desempenho
CPUID
RDTSC
sub eax, ciclo0
mov totalciclos, eax
}
dif4 = dif4 - totalciclos;
printf("Multiplicacao das matrizes com assembly 4\n");
printf("Total de ciclos: %d\n",totalciclos);
//Fim da parte em C usando instruções assembly "inline".

//Análise de desempenho
printf("\n\n Analise de desempenho\n");
printf ("Diferenca do num. de ciclos para a multiplicacao 1: %d\n", dif1);
printf ("Diferenca do num. de ciclos para a multiplicacao 2: %d\n", dif2);
printf ("Diferenca do num. de ciclos para a multiplicacao 3: %d\n", dif3);
printf ("Diferenca do num. de ciclos para a multiplicacao 4: %d\n\n", dif4);
ganho1 = (dif1*100)/conv1;
ganho2 = (dif2*100)/conv2;
ganho3 = (dif3*100)/conv3;
ganho4 = (dif4*100)/conv4;
printf ("Ganho percentual para a multiplicacao 1: %d\n", ganho1);
printf ("Ganho percentual para a multiplicacao 2: %d\n", ganho2);
printf ("Ganho percentual para a multiplicacao 3: %d\n", ganho3);
printf ("Ganho percentual para a multiplicacao 4: %d\n", ganho4);
//Fim da análise de desempenho

return 0;
}