Akselerasi GPU dengan LiteRT

Unit Pemrosesan Grafis (GPU) umumnya digunakan untuk akselerasi deep learning karena throughput paralelnya yang sangat besar dibandingkan dengan CPU. LiteRT menyederhanakan proses penggunaan akselerasi GPU dengan memungkinkan pengguna menentukan akselerasi hardware sebagai parameter saat membuat Model yang Dikompilasi (CompiledModel).

Dengan akselerasi GPU LiteRT, Anda dapat membuat buffer input dan output yang kompatibel dengan GPU, mencapai penyalinan nol dengan data Anda di memori GPU, dan menjalankan tugas secara asinkron untuk memaksimalkan paralelisme.

Untuk contoh penerapan GPU LiteRT, lihat aplikasi demo berikut:

• Segmentasi gambar dengan Kotlin
• Segmentasi asinkron dengan C++

Menambahkan dependensi GPU

Gunakan langkah-langkah berikut untuk menambahkan dependensi GPU ke aplikasi Kotlin atau C++ Anda.

Kotlin

Untuk pengguna Kotlin, akselerator GPU sudah tersedia dan tidak memerlukan langkah tambahan di luar panduan Mulai.

C++

Untuk pengguna C++, Anda harus membuat dependensi aplikasi dengan akselerasi GPU LiteRT. Aturan cc_binary yang mengemas logika aplikasi inti (misalnya, main.cc) memerlukan komponen runtime berikut:

• Library bersama LiteRT C API: atribut data harus menyertakan library bersama LiteRT C API (//litert/c:litert_runtime_c_api_shared_lib) dan komponen khusus GPU (@litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so).
• Dependensi atribut: Atribut deps biasanya mencakup dependensi GLES gles_deps(), dan linkopts biasanya mencakup gles_linkopts(). Keduanya sangat relevan untuk akselerasi GPU, karena LiteRT sering menggunakan OpenGLES di Android.
• File model dan aset lainnya: Disertakan melalui atribut data.

Berikut adalah contoh aturan cc_binary:

cc_binary(
    name = "your_application",
    srcs = [
        "main.cc",
    ],
    data = [
        ...
        # litert c api shared library
        "//litert/c:litert_runtime_c_api_shared_lib",
        # GPU accelerator shared library
        "@litert_gpu//:jni/arm64-v8a/libLiteRtGpuAccelerator.so",
    ],
    linkopts = select({
        "@org_tensorflow//tensorflow:android": ["-landroid"],
        "//conditions:default": [],
    }) + gles_linkopts(), # gles link options
    deps = [
        ...
        "//litert/cc:litert_tensor_buffer", # litert cc library
        ...
    ] + gles_deps(), # gles dependencies
)

Penyiapan ini memungkinkan biner yang dikompilasi Anda memuat dan menggunakan GPU secara dinamis untuk inferensi machine learning yang dipercepat.

Menggunakan GPU dengan CompiledModel API

Untuk mulai menggunakan akselerator GPU, teruskan parameter GPU saat membuat Model yang Dikompilasi (CompiledModel). Cuplikan kode berikut menunjukkan implementasi dasar dari seluruh proses:

// 1. Load model
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));

// 2. Create a compiled model targeting GPU
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model, CompiledModel::Create(env, model, kLiteRtHwAcceleratorGpu));

// 3. Prepare input/output buffers
LITERT_ASSIGN_OR_RETURN(auto input_buffers, compiled_model.CreateInputBuffers());
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// 4. Fill input data (if you have CPU-based data)
input_buffers[0].Write<float>(absl::MakeConstSpan(cpu_data, data_size));

// 5. Execute
compiled_model.Run(input_buffers, output_buffers);

// 6. Access model output
std::vector<float> data(output_data_size);
output_buffers.Read<float>(absl::MakeSpan(data));

// Load model and initialize runtime
val  model =
    CompiledModel.create(
        context.assets,
        "mymodel.tflite",
        CompiledModel.Options(Accelerator.GPU),
        env,
    )

// Preallocate input/output buffers
val inputBuffers = model.createInputBuffers()
val outputBuffers = model.createOutputBuffers()

// Fill the first input
inputBuffers[0].writeFloat(FloatArray(data_size) { data_value /* your data */ })

// Invoke
model.run(inputBuffers, outputBuffers)

// Read the output
val outputFloatArray = outputBuffers[0].readFloat()

Untuk mengetahui informasi selengkapnya, lihat panduan Mulai Menggunakan C++ atau Mulai Menggunakan Kotlin.

Tanpa salinan dengan akselerasi GPU

Penggunaan salinan nol memungkinkan GPU mengakses data secara langsung di memorinya sendiri tanpa perlu CPU menyalin data tersebut secara eksplisit. Dengan tidak menyalin data ke dan dari memori CPU, salinan nol dapat mengurangi latensi end-to-end secara signifikan.

Kode berikut adalah contoh penerapan GPU Zero-Copy dengan OpenGL, API untuk merender grafik vektor. Kode meneruskan gambar dalam format buffer OpenGL langsung ke LiteRT:

// Suppose you have an OpenGL buffer consisting of:
// target (GLenum), id (GLuint), size_bytes (size_t), and offset (size_t)
// Load model and compile for GPU
LITERT_ASSIGN_OR_RETURN(auto model, Model::CreateFromFile("mymodel.tflite"));
LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, kLiteRtHwAcceleratorGpu));

// Create a TensorBuffer that wraps the OpenGL buffer.
LITERT_ASSIGN_OR_RETURN(auto tensor_type, model.GetInputTensorType("input_tensor_name"));
LITERT_ASSIGN_OR_RETURN(auto gl_input_buffer, TensorBuffer::CreateFromGlBuffer(env,
    tensor_type, opengl_buffer.target, opengl_buffer.id, opengl_buffer.size_bytes, opengl_buffer.offset));
std::vector<TensorBuffer> input_buffers{gl_input_buffer};
LITERT_ASSIGN_OR_RETURN(auto output_buffers, compiled_model.CreateOutputBuffers());

// Execute
compiled_model.Run(input_buffers, output_buffers);

// If your output is also GPU-backed, you can fetch an OpenCL buffer or re-wrap it as an OpenGL buffer:
LITERT_ASSIGN_OR_RETURN(auto out_cl_buffer, output_buffers[0].GetOpenClBuffer());

Eksekusi asinkron

Metode asinkron LiteRT, seperti RunAsync(), memungkinkan Anda menjadwalkan inferensi GPU sambil melanjutkan tugas lain menggunakan CPU atau NPU. Dalam pipeline yang kompleks, GPU sering digunakan secara asinkron bersama CPU atau NPU.

Cuplikan kode berikut dibuat berdasarkan kode yang diberikan dalam contoh Akselerasi GPU salinan nol. Kode menggunakan CPU dan GPU secara asinkron dan melampirkan Event LiteRT ke buffer input. LiteRT Event bertanggung jawab untuk mengelola berbagai jenis primitif sinkronisasi, dan kode berikut membuat objek Peristiwa LiteRT terkelola berjenis LiteRtEventTypeEglSyncFence. Objek Event ini memastikan bahwa kita tidak membaca dari buffer input hingga GPU selesai. Semua ini dilakukan tanpa melibatkan CPU.

LITERT_ASSIGN_OR_RETURN(auto env, Environment::Create({}));
LITERT_ASSIGN_OR_RETURN(auto compiled_model,
    CompiledModel::Create(env, model, kLiteRtHwAcceleratorGpu));

// 1. Prepare input buffer (OpenGL buffer)
LITERT_ASSIGN_OR_RETURN(auto gl_input,
    TensorBuffer::CreateFromGlBuffer(env, tensor_type, opengl_tex));
std::vector<TensorBuffer> inputs{gl_input};
LITERT_ASSIGN_OR_RETURN(auto outputs, compiled_model.CreateOutputBuffers());

// 2. If the GL buffer is in use, create and set an event object to synchronize with the GPU.
LITERT_ASSIGN_OR_RETURN(auto input_event,
    Event::CreateManagedEvent(env, LiteRtEventTypeEglSyncFence));
inputs[0].SetEvent(std::move(input_event));

// 3. Kick off the GPU inference
compiled_model.RunAsync(inputs, outputs);

// 4. Meanwhile, do other CPU work...
// CPU Stays busy ..

// 5. Access model output
std::vector<float> data(output_data_size);
outputs[0].Read<float>(absl::MakeSpan(data));

Model yang didukung

LiteRT mendukung akselerasi GPU dengan model berikut. Hasil benchmark didasarkan pada pengujian yang dijalankan di perangkat Samsung Galaxy S24.