1. Foren
  2. Kommentare
  3. PC-Hardware
  4. Alle Kommentare zum Artikel
  5. › Knights Corner: Intels Larrabee…

1 Teraflops

  1. Thema

Neues Thema Ansicht wechseln


  1. 1 Teraflops

    Autor: tingelchen 16.11.11 - 16:01

    Ein hoher Wert. Aber ist die Frage was genau damit denn nun beschleunigt werden soll. Denn für reine Vector Operationen sind die aktuellen Spitzenmodelle von AMD und nVidia sicherlich immer noch schneller, weil die Kerne darauf ausgelegt sind und auch deutlich mehr Operationen parallel durchgeführt werden können und jede Operation in einem kürzeren Zeitraum.

    Die MIC's sind nun einmal nicht darauf optimiert mit Vektoren und Matrizen zu rechnen.

  2. Re: 1 Teraflops

    Autor: dailydols 16.11.11 - 20:04

    Ich habe schon das eine oder andere mal für GPUs programmiert, und ich halte es für gewöhnungsbedüftig. Besonders da die Compiler nur eine Teilmenge z.B. von C/C++ unterstützen. Und das Framework für das Ansprechen der GPUs bedeutet auch Mehraufwand. Wenn man stattdessen auf vielen CPU-Kernen programmieren kann ist es einfacher, da kann man einfach OpenMP oder Intel TBB benutzen. Mit SSE/SSE2 kann man auch da Vektoroperationen gut optimieren, und ein grosser gemeinsamer Cache kümmert sich um den Datenaustausch.

  3. Re: 1 Teraflops

    Autor: asakagi 16.11.11 - 21:42

    OpenCL zu benutzen ist eigentlich nicht so kompliziert. Du kannst ziemlich viel vereinfachen, wenn du mit C++ fit bist.

    z.B.
    ClDef(MyKernels,
    __kernel void Test(__global ushort* input,__global ushort* output)
    {
    const int width = get_global_size(0);
    const int height = get_global_size(1);

    const int x = get_global_id(0);
    const int y = get_global_id(1);

    output[y*width+x] = input[y*width+x]*input[y*width+x];
    }
    );

    int main()
    {
    const int width = 800;
    const int height = 600;

    ClControl GPU;
    GPU.GenKernel(MyKernels);

    std::vector<unsigned short> InFrame(width*height);
    std::vector<unsigned short> OutFrame(width*height);

    ClBuffer InGPU = GPU.CreateBuffer(InFrame);
    ClBuffer OutGPU = GPU.CreateBuffer(OutFrame);

    GPU.CopyToGPU(InGPU,InFrame);
    GPU["Test"] .A(InGPU) .A(OutGPU) .Execute(width,height);
    GPU.CopyFromGPU(OutFrame,OutGPU);

    return 0;
    }

  4. Re: 1 Teraflops

    Autor: Threat-Anzeiger 17.11.11 - 00:46

    tingelchen schrieb:
    --------------------------------------------------------------------------------
    > Ein hoher Wert. Aber ist die Frage was genau damit denn nun beschleunigt
    > werden soll. Denn für reine Vector Operationen sind die aktuellen
    > Spitzenmodelle von AMD und nVidia sicherlich immer noch schneller, weil die
    > Kerne darauf ausgelegt sind und auch deutlich mehr Operationen parallel
    > durchgeführt werden können und jede Operation in einem kürzeren Zeitraum.
    >
    > Die MIC's sind nun einmal nicht darauf optimiert mit Vektoren und Matrizen
    > zu rechnen.


    Die frage ist was du berechnen möchtest. So ist zb eine GPU für lineare operationen(zb hash-algorithmen oder DCTs) geeigneter. Für gewisse andere algorithmen(zb Blake512, einen der SHA-3 kandidaten) ist eine GPU wegen ihrer begrenzten Speicheroperationen hingegen weniger geeignet. Kurzum: Many-Core x86 Karten schlagen herkömmliche GPUs überall dort, wo universellere berechnungen gefordert sind.

  1. Thema

Neues Thema Ansicht wechseln


Um zu kommentieren, loggen Sie sich bitte ein oder registrieren Sie sich. Sie müssen ausserdem in Ihrem Account-Profil unter Forum einen Nutzernamen vergeben haben. Zum Login

Stellenmarkt
  1. Deutsches Patent- und Markenamt, München
  2. Erzbistum Paderborn, Paderborn
  3. KBV Kassenärztliche Bundesvereinigung, Berlin
  4. Allianz Deutschland AG, München Unterföhring

Golem pur
  • Golem.de ohne Werbung nutzen

Anzeige
Hardware-Angebote
  1. (reduzierte Überstände, Restposten & Co.)


Haben wir etwas übersehen?

E-Mail an news@golem.de