X87 - 32 bit Derleme
X87 FPU yazısına göz atabilirsiniz.
fdiv
Sanırım bölme işlemi
yapıyor.
fistp
float -> int çevrimi için
kullanılır.
mov
Kullanım şekli
şöyle.
mov mem, reg
mov reg, mem
mov reg, reg
mov reg, imm
mov mem, imm
Açıklaması
şöyle
Most x86 instructions (other than some specialized instructions such as movsb) can only access one memory location. Therefore a move from memory to memory requires going through a register with two mov instructions.
Elimizde şöyle bir kod
olsun
x = y;
Assembly kodu
şöyledir
movl -0x8(%rbp), %esi
movl %esi, -0xc(%rbp)
Streaming SIMD Extensions 2 - SSE2 - 64 bit Derleme
Tüm modern işlemciler (Intel veya AMD) SSE2'yi
desteklerler.Açıklaması
şöyle.
SSE2 was introduced into Intel chips with the Pentium 4 in 2001 and AMD processors in 2003
Visual Studio 2012'den itibaren 64 bit kodlar için
SSE2 kodları üretiyor. SSE2 kodları XMM yazmaçlarını kullanır. Assembly kodu
şöyledir
movsd QWORD PTR [rsp+8], xmm1
call cos
movsd xmm1, QWORD PTR [rsp+8]
movsd QWORD PTR [rsp], xmm0
movapd xmm0, xmm1
call cos
movsd xmm2, QWORD PTR [rsp]
ucomisd xmm2, xmm0
divss
Sanırım bölme işlemi
yapıyor. gcc'de şöyle
yaparız.
__m128 s1, s2;
s1 = _mm_set_ps(1.0, 1.0, 1.0, 1.0);
s2 = _mm_set_ps(0.0, 0.0, 0.0, 0.0);
s2 = _mm_div_ss(s1, s2);
_mm_loadu_si128
Elimizde bir dizi
olsun.
short* tempBufferVert = new short[width * height];
Dizideki her elemanı 4 il bölmek için şöyle
yaparız.
#include <emmintrin.h> // SSE2
for (int i = 0; i < width * height; i += 8)
{
__m128i v = _mm_loadu_si128((__m128i *)&tempBufferVert[i]);
v = _mm_srai_epi16(v, 2); // v >>= 2
_mm_storeu_si128((__m128i *)&tempBufferVert[i], v);
}
setcsr
Şöyle yaparız.
_mm_setcsr (0x00001D80);
Intel 80 bit floating point
80 bitlik precision bazı C++ derleyicileri tarafından kullanılabiliyor. Açıklaması
şöyle.
The C++ standard allows implementations to evaluate floating-point expressions with more precision than the nominal type requires.
C# için de aynı kural geçerli.Açıklaması
şöyle.
In particular, in some situations the JIT is permitted to use a more accurate intermediate representation - e.g. 80 bits when your original data is 64 bits - whereas in other situations it won't. That can result in seeing different results when any of the following is true:
Bir başka açıklama
şöyle.
The IEEE 754 specifies that computations can be processed at a higher precision than what is stored in memory then rounded when written back to memory ..... In short, the standard does not promise that the same computation carried out on all hardware will return the same answer.
Örnek
Aşağıdaki basit örnekte derleyicinin iki double sayısını çarparken fazla precision kullandığını
görebiliriz.
#include <cstdint>
#include <cinttypes>
#include <cstdio>
using namespace std;
int main() {
double xd = 1.18;
int64_t xi = 1000000000;
int64_t res1 = (double)(xi * xd);
double d = xi * xd;
int64_t res2 = d;
printf("%" PRId64"\n", res1);
printf("%" PRId64"\n", res2);
}
Çıktı olarak şunu alırız.
1179999999
1180000000
Örnek
32 ve 64'bitlik uygulamalar arasında da farklar
olabilir.
long double dvalue = 2.7182818284589998;
long double dexp = -0.21074699576017999;
long double result = std::powl( dvalue, dexp)
Sonuç olarak şunu alırız.
64bit -> result = 0.80997896907296496 and 32bit -> result = 0.80997896907296507
FPU içindeki kayan nokta hesaplaması için kullanılan register'lar 80 bit olabiliyor.
C ile kullanılan long double 80 bitlik bu veri tipine denk
gelebilir. Bu durumda iki farklı makine arasında aynı hesaplamayı yapsak bile farklı sonuçlar elde edilebilir. Derleyiciler strict mode çalışmaya zorlanarak farklı makineler arasında aynı sonucu elde etmek mümkün.
C++
1. /fp:precise - MS derleyici için kullanılır
Varsayılan seçenek budur. Açıklaması
şöyle
fp:precise weakens some of the rules, however it warranties that the precision of the calculations will not be lost.
Ara değerlerin (intermediate value) FPU registerlarında saklanmasına müsaade etmez. Hesaplamadan sonra ara değerler bellekteki alana geri
yazılır. Açıklaması şöyle özellike x87 kodlarında bu açıklama
önemli.
If the value to be computed on is placed on a larger register then one computation is done and then the value is moved off of the register back to memory the result is truncated there. It could then be moved back on to the larger register for another computation.
On the other hand if all the computations are done on the larger register before the value is moved back to memory you will get a different result.
Bu seçenek Visual C++ 6.0 ile kullanılan /Op (Improve Float Consistency) seçeneğinin yerini almıştır. Eski seçenek için de benzer bir açıklama Açıklaması
şöyleydi
By default, the compiler uses the coprocessor’s 80-bit registers to hold the intermediate results of floating-point calculations. This increases program speed and decreases program size. However, because the calculation involves floating-point data types that are represented in memory by less than 80 bits, carrying the extra bits of precision (80 bits minus the number of bits in a smaller floating-point type) through a lengthy calculation can produce inconsistent results.
2. /fp:strict - MS derleyici için kullanılır
