Die Messung der Ausführungszeit der OpenCL-Kernel

Habe ich die folgende Schleife, die die Zeit misst, die von meinem Kernel:

double elapsed = 0;
cl_ulong time_start, time_end;
for (unsigned i = 0; i < NUMBER_OF_ITERATIONS; ++i)
{
    err = clEnqueueNDRangeKernel(queue, kernel, 1, NULL, &global, NULL, 0, NULL, &event); checkErr(err, "Kernel run");
    err = clWaitForEvents(1, &event); checkErr(err, "Kernel run wait fro event");
    err = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, NULL); checkErr(err, "Kernel run get time start");
    err = clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(time_end), &time_end, NULL); checkErr(err, "Kernel run get time end");
    elapsed += (time_end - time_start);
}

Dann Teile ich elapsed durch NUMBER_OF_ITERATIONS um die endgültige Schätzung. Ich befürchte allerdings, der Zeitpunkt der Ausführung der einzelnen kernels ist zu klein und daher kann die Unsicherheit in meiner Messung. Wie kann ich Messen die Zeit, die für alle NUMBER_OF_ITERATIONS Kernel kombiniert?

Können Sie vorschlagen, ein profiling-Instrument, das helfen könnte, da ich nicht benötigen Zugriff auf diese Daten programmgesteuert. Ich benutze NVIDIA-OpenCL.

InformationsquelleAutor user1096294 | 2014-05-08
  1. 11

    müssen Sie befolgen Sie die nächsten Schritte zur Messung der Ausführungszeit der OpenCL-kernel-Ausführungszeit:

    1.Erstellen Sie eine Warteschlange, profiling müssen schon aktivieren, wenn die Warteschlange erstellt wird: 

    cl_command_queue command_queue;
command_queue = clCreateCommandQueue(context, devices[deviceUsed], CL_QUEUE_PROFILING_ENABLE, &err);

    2.Link ein Ereignis beim Start eine kernel -

    cl_event event;
err=clEnqueueNDRangeKernel(queue, kernel, woridim, NULL, workgroupsize, NULL, 0, NULL, &event);

    3.Warten Sie, bis der kernel fertig

    clWaitForEvents(1, &event);

    4.Warten Sie, bis alle in die Warteschlange eingereiht Aufgaben zu erledigen,

    clFinish(queue);

    5.Holen Sie profiling-Daten und berechnen Sie die kernel-Ausführungszeit (zurückgegeben von der OpenCL-API in Nanosekunden)

    cl_ulong time_start;
cl_ulong time_end;

clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_START, sizeof(time_start), &time_start, NULL);
clGetEventProfilingInfo(event, CL_PROFILING_COMMAND_END, sizeof(time_end), &time_end, NULL);

double nanoSeconds = time_end-time_start;
printf("OpenCl Execution time is: %0.3f milliseconds \n",nanoSeconds /1000000.0);
    InformationsquelleAutor Dongwei Wang
  2. 3

    Profiling-Funktion gibt nano-Sekunden und ist sehr genau (~50ns), aber die Ausführung hat unterschiedliche Laufzeiten, abhängig von anderen kleinere Probleme, die Sie nicht kontrollieren können.

    Dies reduziert Ihr problematisch ist, was Sie Messen wollen:

    • Messung der kernel-Ausführungszeit: Dein Ansatz ist richtig, die Genauigkeit der durchschnittlichen Ausführungszeit gemessen wird, zu erhöhen, da Sie erhöhen N. Diese Konten nur für die Ausführung Zeit, keine Gemeinkosten berücksichtigt.

    • Messung der kernel-Ausführungszeit + overhead: Sie sollten die Ereignisse als gut, aber Messen, da CL_PROFILING_COMMAND_SUBMIT, um Konto für die zusätzliche Ausführung overhead.

    • Messung der echte host-side execution time: Sie sollten die Ereignisse als gut, aber Messen, da die erste Veranstaltung starten, um das Letzte event zu Ende. Mit CPU-timing-Messung ist eine weitere Möglichkeit. Wenn Sie Messen möchten, dann sollten Sie entfernen Sie die waitforevents aus der Schleife, ermöglichen maximale Durchsatz, um die OpenCL-system (und mit weniger Aufwand möglich).

    Beantwortung der Tools in Frage, ich empfehle die Verwendung von nVIDIA visual profiler. Aber da ist nicht mehr verfügbar für OpenCL, sollten Sie die Visual Studio-Add-on oder eine alte version (CUDA 3.0) der nvprofiler.

    InformationsquelleAutor DarkZeros
  3. 1

    Die Zeit gemessen wird, der zurückgegeben wird, in Nanosekunden, aber du hast Recht: Die Auflösung des Timers niedriger ist. Allerdings Frage ich mich, was die tatsächliche Ausführungszeit des Kernels ist, wenn Sie sagen, die Zeit ist zu kurz, um genau Messen (mein Gefühl ist, dass die Auflösung sollte im Bereich von Mikrosekunden).

    Die am besten geeignete Art und Weise der Messung der Gesamtzeit von mehreren Iterationen hängt davon ab, was "mehrere" bedeutet hier. Ist NUMBER_OF_ITERATIONS=5 oder NUMBER_OF_ITERATIONS=500000? Wenn die Anzahl der Iterationen ist "groß", Sie können einfach verwenden Sie die system-Uhr, ggf. mit OS-spezifischen Funktionen, wie QueryPerformanceCounter auf windows (siehe auch, zum Beispiel, Gibt es eine Möglichkeit, um die Zeit zu Messen bis zu Mikro-Sekunden mit C standard-Bibliothek? ), aber natürlich auch die Präzision, mit der die system Uhr könnte niedriger sein, als die von der OpenCL-device, also, ob das Sinn macht wirklich hängt von der Anzahl der Iterationen.

    Es ist schade, dass NVIDIA entfernt OpenCL-Unterstützung aus Ihrer Visual Profiler, aber...

    • Danke für die Antwort! Wir sprechen von zig-Mikrosekunden und NUMBER_OF_ITERATIONS willkürlich ist wirklich. Jetzt war ich mit 30. Ich brauche eine gute Zahl, um loszuwerden, der Fehler.
    InformationsquelleAutor Marco13
  4. 0

    Auf Intel-OpenCL-GPU-Implementierung, die ich habe erfolgreich mit Ihrem Konzept (timing-pro kernel) und ziehe es Gemenge einen Strom von NDRanges.

    • Ein alternativer Ansatz ist die Ausführung N-mal mit und Messen die Zeit mit Marker-Ereignisse, wie im vorgeschlagenen Ansatz in diese Frage (die Frage, nicht die Antwort).

    • Mal für kurze Kerne sind in der Regel zumindest in den Mikrosekunden-Bereich in meiner Erfahrung.

    • Können Sie die timer-Auflösung mit clGetDeviceInfo mit CL_DEVICE_PROFILING_TIMER_RESOLUTION (z.B. 80 ns auf meinem setup).

    InformationsquelleAutor Tim
Schreibe einen Kommentar