Float vs Double Performance

Tôi đã thực hiện một số bài kiểm tra thời gian và cũng đọc một số bài viết như bài này (nhận xét cuối cùng) và có vẻ như trong bản dựng Release, các giá trị float và double mất cùng một lượng thời gian xử lý.

Sao có thể như thế được? Khi float kém chính xác hơn và nhỏ hơn so với các giá trị gấp đôi, làm thế nào CLR có thể nhận được gấp đôi trong cùng một thời gian xử lý?

Trên các bộ xử lý x86, ít nhất floatvà doublemỗi bộ sẽ được chuyển đổi thành giá trị thực 10 byte bởi FPU để xử lý. FPU không có các đơn vị xử lý riêng biệt cho các kiểu dấu phẩy động khác nhau mà nó hỗ trợ.

Lời khuyên lâu đời floathơn doubleđược áp dụng cách đây 100 năm khi hầu hết các CPU không có FPU tích hợp (và ít người có chip FPU riêng biệt), vì vậy hầu hết các thao tác dấu phẩy động đều được thực hiện trong phần mềm. Trên các máy (mà được cung cấp bởi hơi nước được tạo ra bởi các hố nham thạch), nó là nhanh hơn để sử dụng floats. Giờ đây, lợi ích thực sự duy nhất đối với floats là chúng chiếm ít dung lượng hơn (điều này chỉ quan trọng nếu bạn có hàng triệu người trong số chúng).

Tôi đã có một dự án nhỏ trong đó tôi sử dụng CUDA và tôi có thể nhớ rằng float cũng nhanh hơn gấp đôi ở đó. Khi lưu lượng giữa Máy chủ và Thiết bị thấp hơn (Máy chủ là CPU và RAM "bình thường" và Thiết bị là GPU và RAM tương ứng ở đó). Nhưng ngay cả khi dữ liệu luôn nằm trên Thiết bị, nó vẫn chậm hơn. Tôi nghĩ rằng tôi đã đọc ở đâu đó rằng điều này đã thay đổi gần đây hoặc được cho là sẽ thay đổi với thế hệ tiếp theo, nhưng tôi không chắc.

Vì vậy, có vẻ như GPU chỉ đơn giản là không thể xử lý độ chính xác gấp đôi nguyên bản trong những trường hợp đó, điều này cũng sẽ giải thích tại sao GLFloat thường được sử dụng hơn là GLDouble.

(Như tôi đã nói, nó chỉ theo chừng mực tôi có thể nhớ được, tôi chỉ tình cờ phát hiện ra điều này khi đang tìm kiếm float so với double trên CPU.)

Tuy nhiên, vẫn có một số trường hợp mà float được ưu tiên hơn - ví dụ như với mã hóa OpenGL, việc sử dụng kiểu dữ liệu GLFloat (thường được ánh xạ trực tiếp tới float 16 bit) phổ biến hơn nhiều vì nó hiệu quả hơn trên hầu hết các GPU so với GLDouble.

Nó phụ thuộc vào hệ thống 32 bit hoặc 64 bit . Nếu bạn biên dịch sang 64-bit, gấp đôi sẽ nhanh hơn. Được biên dịch thành 32-bit trên 64-bit (máy và hệ điều hành) giúp trôi nổi nhanh hơn khoảng 30%:

    public static void doubleTest(int loop)
    {
        Console.Write("double: ");
        for (int i = 0; i < loop; i++)
        {
            double a = 1000, b = 45, c = 12000, d = 2, e = 7, f = 1024;
            a = Math.Sin(a);
            b = Math.Asin(b);
            c = Math.Sqrt(c);
            d = d + d - d + d;
            e = e * e + e * e;
            f = f / f / f / f / f;
        }
    }

    public static void floatTest(int loop)
    {
        Console.Write("float: ");
        for (int i = 0; i < loop; i++)
        {
            float a = 1000, b = 45, c = 12000, d = 2, e = 7, f = 1024;
            a = (float) Math.Sin(a);
            b = (float) Math.Asin(b);
            c = (float) Math.Sqrt(c);
            d = d + d - d + d;
            e = e * e + e * e;
            f = f / f / f / f / f;
        }
    }

    static void Main(string[] args)
    {
        DateTime time = DateTime.Now;
        doubleTest(5 * 1000000);
        Console.WriteLine("milliseconds: " + (DateTime.Now - time).TotalMilliseconds);

        time = DateTime.Now;
        floatTest(5 * 1000000);
        Console.WriteLine("milliseconds: " + (DateTime.Now - time).TotalMilliseconds);

        Thread.Sleep(5000);
    }