mboost-dp1

LLVM 15 med nye sikkerheds funktionaliteter


Gå til bund
Gravatar #1 - arne_v
7. sep. 2022 16:28
https://www.phoronix.com/news/LLVM-15.0-Released
Gravatar #2 - larsp
8. sep. 2022 08:11
Projektet arbejder tydeligvis i retning af GPU og machine learning kode support, ved at inkludere _float16 og f.eks. "8 and 16-bit atomic loads and stores with the AMDGPU back-end."

Det er sjovt hvordan "antal bits" er gået full circle fra 8/16 bit i computerens spæde barndom, op til 64 bit for mainstream CPUer, og nu er vi så tilbage til at skubbe en masse små datatyper igen pga. machine learning og GPUer. Det er selvfølgelig i en helt anden skala. Mainstream GPUer kan levere 10 tera(!) flops i float16, og det går kun op der fra.
Gravatar #3 - arne_v
8. sep. 2022 13:20
#2

Man skal skelne mellem "general bit" og "FP bit".

Generelt er man skiftet (8--->)16 (eller 18)--->32 (eller 36)--->64 bit.

Men FP er anderledes. CDC Cyber fra midt 60'erne brugte 18 bit adresser men havde 60 og 120 bit FP. VAX fra sidst i 70'erne brugte 32 bit adresser men havde 32, 64 og 128 bit FP.


Gravatar #4 - arne_v
8. sep. 2022 13:23
#2

Men lidt sjovt at "latest and greatest" data type er en FP med range -65504..65504 og 3.3 cifres præcision.

Specialiserede problem stillinger kalder tilsyneladende på specialiserede data typer.


Gravatar #5 - larsp
9. sep. 2022 12:19
#3 Ja, det er rigtigt. Antal bits brugt gennem tiderne er et kompliceret emne. Der er også adresse rum bitbredde vs. CPU arbejdsregister bredde.

#4 Det er jo en fin datatype til vægtene i et neuralt netværk. Stor opløsning omkring nul, samtidig med mulighed for store udsving.
Gravatar #6 - arne_v
9. sep. 2022 12:45
larsp (5) skrev:

#4 Det er jo en fin datatype til vægtene i et neuralt netværk. Stor opløsning omkring nul, samtidig med mulighed for store udsving.


Det er en generel egenskab ved FP.

De fleste tænker ikke på FP som en endelig mængde af rationelle tal karakteriseret ved at afstanden mellem værdierne vokser når man bevæger sig væk fra nul, men det er hvad de er.

De fleste tænker på FP som værende alle reelle tal, hvilket er meget forkert.
Gravatar #7 - arne_v
9. sep. 2022 13:00
#6

Og forskellen bliver meget hurtigt tydeligt med half precision.

For dem som vil prøve er det en portabel software C++ implementation her:

http://half.sourceforge.net/


#include <iostream>

using namespace std;

#include "half.hpp"

using namespace half_float;

int main()
{
half x(0);
for(int i = 0; i < 2500; i++)
{
x += 1;
if(i % 100 == 0)
{
cout << (i + 1) << " : " << x << endl;
}
}
return 0;
}


output:

1 : 1
101 : 101
201 : 201
301 : 301
401 : 401
501 : 501
601 : 601
701 : 701
801 : 801
901 : 901
1001 : 1001
1101 : 1101
1201 : 1201
1301 : 1301
1401 : 1401
1501 : 1501
1601 : 1601
1701 : 1701
1801 : 1801
1901 : 1901
2001 : 2001
2101 : 2048
2201 : 2048
2301 : 2048
2401 : 2048
Gravatar #8 - arne_v
10. okt. 2022 15:17
Eller endnu nemmere .NET 7 og C# 11 (forventes klar til November):


using System;

public class Program
{
public static void Main(string[] args)
{
Half x = (Half)0;
for(int i = 0; i < 2500; i++)
{
x = x + (Half)1;
if(i % 100 == 0)
{
Console.WriteLine("{0} : {1}", i + 1, x);
}
}
}
}

Gå til top

Opret dig som bruger i dag

Det er gratis, og du binder dig ikke til noget.

Når du er oprettet som bruger, får du adgang til en lang række af sidens andre muligheder, såsom at udforme siden efter eget ønske og deltage i diskussionerne.

Opret Bruger Login