Fransk myndighet ska utreda Nvidia för konkurrensbrott

Så du menar att allt vad Linux inneburit inte har drivit utvecklingen frammåt, men att varenda företag sätter "AI" på alla sina produkter för att det ska sälja har det?

Jag säger inte att AI inte har potential, men kom tillbaks när det faktiskt har löst riktiga problem, typ förebyggt Cancer, utrotat AIDS, sådanna saker. Att hjälpa redan rika företag att tjäna ännu mer pengar är ingen bedrift.

Och du verkar väldigt säker på att Intel inte hade gjort likadant om de hade varit i Nvidias position? Klart de hade gjort!

Dessutom leder det till konkurrerande öppna standardarder och det gagnar oss slutkonsumenter. Jag ser inga som helst problem med att Nvidia kör sina egna lösningar.

Ethernet? TCP/IP? HTTP? TLS? SMTP? HTML? JSON? XML? För att inte nämna tusentals RFC:er eller ISO-standarder som tillåter diverse industrier att tjäna åtskilliga miljarder.

Monopol har aldrig lätt till bra produkter eller aggressiv utveckling. Bara se hur IE-monopolet höll på att stagnera Internet på 90-talet eller hur dagens sökmonopol för Google har lett till att webbsök samt hemsidor blivit komplett skit.

Det är när du har monopol som du kan sluta innovera för alla måste ända köpa dina produkter. Det är också lite märkligt resonemang att hävda att Nvidia skulle ge upp sin aggressiva utveckling inom GPGPU om de fick riktig konkurrens.

Fransmännen vill också sin beskärda del av "AI-pengarna"...?! 🤷🏼‍♂️ 😅

Jag tänker mest på den instinktiva försvarsmekanismen som går igång hos vissa bara för att de har köpt ett visst märke. Ett mänskligt men fortfarande konstigt beteende.

VESA, DisplayPort, Vulkan, OpenGL... Ska jag fortsätta? Utan dessa skulle GPU-världen vara bra mycket sämre. Man ska inte underskatta värdet av kompabilitet mellan tillverkare, även om det är svårt att dra direkta linjer till inkomst av försäljningen det skapar.

Tycker ändå det finns en hel del som pekar på att just duopol är på många sätt den absolut sämsta varianten av konkurrens.

Ett de-facto monopol kommer bli utsatt för granskning, även om det ibland tar lite tid. Finns gott om exempel på det.

Så fort det är mer än två spelare ändras dynamiken på ett uppenbart sätt: att göra något som är dåligt för den andra parten är inte längre nödvändigtvis fördelaktigt för dig själv, det kan mycket väl gynna de andra mer. Så här får man "riktig" konkurrens.

Även ett duopol med dålig balans är många gånger bättre än ett där båda spelarna är jämbördiga. I det förra gör en allt för att öka sin andel, i det andra finns det ofta så pass mycket att riskera att båda är nöjda med status quo.

För att ta ett aktuellt exempel som nog inte riktigt gått som folk hoppas: CPU-marknaden mellan AMD och Intel. Rätt snabbt efter att det blev "konkurrens" så ökade priset kraftigt på CPU-modeller. Från att under många år legat på ~$300 för toppmodellen och $200 för "mainstream" är det rätt mycket det dubbla idag.

Och har vi egentligen fått något från denna konkurrens? Länge såg det ut som det, men när det började komma in fler spelar undrar jag om inte även det var en illusion. När man är två behöver man inte vara bra, räcker att vara mindre dålig än sin konkurrent.

För 10 år sedan var Intels CPUer ohotade sett till prestanda per kärna. I slutet av detta år kan det mycket väl vara så att AMD och Intel får tävla om 4:e platsen var det gäller prestanda för bärbara, efter Apple, Arm (de kommer vara 2a om vad de säger om Cortex A925 stämmer) och Qualcomm (i "bästa" fall för Intels/AMDs del är de ihop med QCOM i en fight om 3:e plats).

Samma gäller servers. När första Epyc släpptes var det gnäll bl.a. här om hur dyra Xeons var. Dyraste Epyc låg på ~$4k har jag för mig medan dyraste Xeon gick på ~$8k. Idag ser medianpriset på AMDs/Intels server-CPUer ut att ligga över $10k från båda spelarna.

Sen kan man inte bara skylla ökning i pris på detta. Kostnaden för kretstillverkning skenar, så allt bleeding-edge har blivit rejält mycket dyrare. Men att tro att ett duopol ger speciellt mycket för konsumenterna är kanske att hoppas på lite för mycket.

Det skrivet: även om Nvidia nått sin nuvarande position genom att helt enkelt varit tekniskt överlägsna sina konkurrenter under mer än ett decennium så är de idag ett de-facto monopol inom en rad områden. De SKA därför granskas rejält, för de är i en position där de i praktiken helt kan diktera reglerna annars.

Ethernet och TCP/IP är lysande exempel på vad vi får hoppas kommer hända även här. D.v.s. i slutändan kommer vi nästan uteslutande använda oss av öppna standarder som är designade för att fungera så bra som möjligt för alla.

Ethernet och TCP/IP slog ut proprietära tekniker som token ring och SPX/IPX för att de helt enkelt var bättre på många sätt.

Så det vi inte vill se är att man går in och gör något så att Nvidia blir tvingande att låta alla använda CUDA. CUDA är specifikt designat för fungera optimalt på Nvidias HW. SyCL, och även OpenCL 3.x, är designat för att kunna implementeras på ett nära optimalt sätt på en bred uppsättning HW.

Nutida exempel är AMDs Mantle. Det hade väldigt små möjligheter att bli populärt utanför AMDs GPUer, för det fanns flera saker som var specifikt designade för GCN. Skillnaden mellan Vulkan och Mantle handlar nästan uteslutande om att sådant som tar bort sådana egenskaper. Att göra Mantle->Vulkan resan med CUDA är långt mycket mer jobb än att bara kör på med SyCL.

I fallet CUDA är uppförsbacken ovanligt stor för en standard att ta över. Helt enkelt därför Nvidia hunnit bygga så enormt mycket användbart runtomkring som använder CUDA som bas.

Men finns massor med exempel på att det är möjligt. Backa 5 år, att köra PyTorch/Tensorflow på något annat än CPU eller CUDA var rätt mycket ett "no-go".

Idag fungerar det hur bra som helst att även köra med Metal Compute och OneAPI. Finns en hel del kodexempel som inte fungerar out-of-the-box, det för att de hårdkodat cuda som GPU-device. Fixa det så brukar det rullar på även med Metal (mps) eller OneAPI (mer än bara GPGPU, men också det, xpu).

Nvidias bibliotek för CUDA är dock rätt mycket större än så.

Nvidia lär inte bry sig om SyCL så länge som CUDA är de-facto standard.

Men är man på "andra sidan" och bygger applikationer fattade Intel att de är flugviktaren medan Nvidia är tungviktaren. För att accelerera användning av OneAPI behövde man säkerställa att det även fungerar på Nvidias GPUer.

Så Intel har implementerat SyCL-stöd för Nvidias GPUer. Eller för att vara helt korrekt, man har betalat ett företag vid namn CodePlay för att fixa detta stöd.

Det jobbas även på stöd för AMDs GPUer då de också vägrat SyCL stöd, det är i beta just nu.

En av fördelarna med SyCL är att minneshantering hanteras automatiskt compile-time (något som blev möjligt från hur SyCL använder C++17/20 på ett effektivt sätt) medan det måste hanteras manuellt i CUDA (och HIP).

Exempel på GPGPU-världens "hello world", addera två vektorer och lägg resultatet i en tredje vektor.

#include <iostream>
#include <vector>

__global__ void vector_add(const int* A, const int* B, int* C, int size) {
    int i = blockDim.x * blockIdx.x + threadIdx.x;
    if (i < size) {
        C[i] = A[i] + B[i];
    }
}

int main() {
    const int size = 1000;
    std::vector<int> A(size, 1);
    std::vector<int> B(size, 2);
    std::vector<int> C(size, 0);

    int* d_A;
    int* d_B;
    int* d_C;

    cudaMalloc(&d_A, size * sizeof(int));
    cudaMalloc(&d_B, size * sizeof(int));
    cudaMalloc(&d_C, size * sizeof(int));

    cudaMemcpy(d_A, A.data(), size * sizeof(int), cudaMemcpyHostToDevice);
    cudaMemcpy(d_B, B.data(), size * sizeof(int), cudaMemcpyHostToDevice);

    int threadsPerBlock = 256;
    int blocksPerGrid = (size + threadsPerBlock - 1) / threadsPerBlock;

    vector_add<<<blocksPerGrid, threadsPerBlock>>>(d_A, d_B, d_C, size);

    cudaMemcpy(C.data(), d_C, size * sizeof(int), cudaMemcpyDeviceToHost);

    cudaFree(d_A);
    cudaFree(d_B);
    cudaFree(d_C);

    // Verifying the result
    bool correct = true;
    for (int i = 0; i < size; i++) {
        if (C[i] != 3) {
            correct = false;
            break;
        }
    }

    if (correct) {
        std::cout << "Vector addition succeeded." << std::endl;
    } else {
        std::cout << "Vector addition failed." << std::endl;
    }

    return 0;
}

#include <CL/sycl.hpp>
#include <iostream>
#include <vector>

using namespace sycl;

int main() {
    const int size = 1000;
    std::vector<int> A(size, 1);
    std::vector<int> B(size, 2);
    std::vector<int> C(size, 0);

    queue q;

    {
        buffer<int, 1> bufferA(A.data(), range<1>(size));
        buffer<int, 1> bufferB(B.data(), range<1>(size));
        buffer<int, 1> bufferC(C.data(), range<1>(size));

        q.submit([&](handler& h) {
            auto accA = bufferA.get_access<access::mode::read>(h);
            auto accB = bufferB.get_access<access::mode::read>(h);
            auto accC = bufferC.get_access<access::mode::write>(h);

            h.parallel_for(range<1>(size), [=](id<1> i) {
                accC[i] = accA[i] + accB[i];
            });
        });
    }

    // Verifying the result
    bool correct = true;
    for (int i = 0; i < size; i++) {
        if (C[i] != 3) {
            correct = false;
            break;
        }
    }

    if (correct) {
        std::cout << "Vector addition succeeded." << std::endl;
    } else {
        std::cout << "Vector addition failed." << std::endl;
    }

    return 0;
}