blob: 6b8a4500b8dc83b5c64fc06383aefb5fe477817a [file]
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "services/webnn/webnn_tensor_impl.h"
#include "base/synchronization/waitable_event.h"
#include "base/task/bind_post_task.h"
#include "base/threading/thread_restrictions.h"
#include "gpu/command_buffer/service/shared_image/shared_image_representation.h"
#include "services/webnn/error.h"
#include "services/webnn/public/cpp/operand_descriptor.h"
#include "services/webnn/public/cpp/webnn_trace.h"
#include "services/webnn/public/mojom/webnn_tensor.mojom.h"
#include "services/webnn/scoped_gpu_sequence.h"
#include "services/webnn/webnn_context_impl.h"
namespace webnn {
WebNNTensorImpl::WebNNTensorImpl(
mojo::PendingAssociatedReceiver<mojom::WebNNTensor> receiver,
WebNNContextImpl& context,
mojom::TensorInfoPtr tensor_info)
: WebNNObjectImpl<mojom::WebNNTensor,
blink::WebNNTensorToken,
mojo::AssociatedReceiver<mojom::WebNNTensor>>(
std::move(receiver),
context.scheduler_task_runner(),
context.owning_task_runner()),
context_(context),
descriptor_(std::move(tensor_info->descriptor)),
usage_(std::move(tensor_info->usage)) {}
WebNNTensorImpl::WebNNTensorImpl(
mojo::PendingAssociatedReceiver<mojom::WebNNTensor> receiver,
WebNNContextImpl& context,
mojom::TensorInfoPtr tensor_info,
RepresentationPtr representation)
: WebNNObjectImpl<mojom::WebNNTensor,
blink::WebNNTensorToken,
mojo::AssociatedReceiver<mojom::WebNNTensor>>(
std::move(receiver),
context.scheduler_task_runner(),
context.owning_task_runner()),
context_(context),
representation_(std::move(representation)),
descriptor_(std::move(tensor_info->descriptor)),
usage_(std::move(tensor_info->usage)) {}
WebNNTensorImpl::~WebNNTensorImpl() = default;
bool WebNNTensorImpl::IsValidWithDescriptor(
const OperandDescriptor& descriptor) const {
return descriptor_ == descriptor;
}
void WebNNTensorImpl::ReadTensor(ReadTensorCallback callback) {
ScopedTrace scoped_trace("WebNNTensorImpl::ReadTensor");
if (!usage().Has(MLTensorUsageFlags::kRead)) {
GetMojoReceiver().ReportBadMessage(kBadMessageInvalidTensor);
return;
}
// Ensure the Mojo callback is posted back to the task runner. Running
// it directly on the GPU sequence can violate Mojo's sequence checks,
// even if executing on the same thread.
auto mojo_callback_wrapper = base::BindPostTask(
context_->scheduler_task_runner(), std::move(callback));
// Call ReadTensorImpl() implemented by a backend.
context_->gpu_sequence()->ScheduleGpuTask(base::BindOnce(
[](WebNNTensorImpl* self, ReadTensorCallback callback,
ScopedTrace scoped_trace,
mojo::ReportBadMessageCallback bad_message_cb) {
if (self->is_exported()) {
LOG(ERROR) << "[WebNN] Invalid to read tensor when exported.";
std::move(bad_message_cb).Run(kBadMessageInvalidTensor);
return;
}
self->ReadTensorImpl(std::move(callback));
},
base::RetainedRef(this), std::move(mojo_callback_wrapper),
std::move(scoped_trace), GetMojoReceiver().GetBadMessageCallback()));
}
void WebNNTensorImpl::WriteTensor(mojo_base::BigBuffer src_buffer) {
ScopedTrace scoped_trace("WebNNTensorImpl::WriteTensor");
if (!usage().Has(MLTensorUsageFlags::kWrite)) {
GetMojoReceiver().ReportBadMessage(kBadMessageInvalidTensor);
return;
}
// TODO(https://crbug.com/40278771): Generate error using MLContext.
// The size of src_buffer should be either equal to the packed byte length of
// the tensor, or zero, which requires a valid write tensor consumer.
if ((src_buffer.size() != PackedByteLength() && src_buffer.size() != 0) ||
(src_buffer.size() == 0 && !context_->HasValidWriteTensorConsumer())) {
GetMojoReceiver().ReportBadMessage(kBadMessageInvalidTensor);
return;
}
// Call WriteTensorImpl() implemented by a backend.
context_->gpu_sequence()->ScheduleGpuTask(base::BindOnce(
[](WebNNTensorImpl* self, mojo_base::BigBuffer src_buffer,
ScopedTrace scoped_trace,
mojo::ReportBadMessageCallback bad_message_cb) {
if (self->is_exported()) {
LOG(ERROR) << "[WebNN] Invalid to write tensor when exported.";
std::move(bad_message_cb).Run(kBadMessageInvalidTensor);
return;
}
self->WriteTensorImpl(std::move(src_buffer));
},
base::RetainedRef(this), std::move(src_buffer), std::move(scoped_trace),
GetMojoReceiver().GetBadMessageCallback()));
}
void WebNNTensorImpl::ImportTensor(const gpu::SyncToken& fence) {
ScopedTrace scoped_trace("WebNNTensorImpl::ImportTensor");
if (!usage().Has(MLTensorUsageFlags::kWebGpuInterop)) {
GetMojoReceiver().ReportBadMessage(kBadMessageInvalidTensor);
return;
}
// Defer the next task until the fence is released, after prior scheduled
// tasks run.
context_->gpu_sequence()->ScheduleGpuTask(
base::BindOnce(
[](WebNNTensorImpl* self, ScopedTrace scoped_trace,
mojo::ReportBadMessageCallback bad_message_cb) {
if (!self->is_exported()) {
LOG(ERROR)
<< "[WebNN] ImportTensor called without the tensor being "
"exported.";
std::move(bad_message_cb).Run(kBadMessageInvalidTensor);
return;
}
if (!self->ImportTensorInternal()) {
LOG(ERROR)
<< "[WebNN] Failed to import tensor from shared image.";
std::move(bad_message_cb).Run(kBadMessageInvalidTensor);
return;
}
},
base::RetainedRef(this), std::move(scoped_trace),
GetMojoReceiver().GetBadMessageCallback()),
{fence});
}
void WebNNTensorImpl::ExportTensor(ExportTensorCallback callback) {
ScopedTrace scoped_trace("WebNNTensorImpl::ExportTensor");
if (!usage().Has(MLTensorUsageFlags::kWebGpuInterop)) {
GetMojoReceiver().ReportBadMessage(kBadMessageInvalidTensor);
return;
}
// Ensure the Mojo callback is posted back to the task runner. Running
// it directly on the GPU sequence can violate Mojo's sequence checks,
// even if executing on the same thread.
auto mojo_callback_wrapper = base::BindPostTask(
context_->scheduler_task_runner(), std::move(callback));
// TODO(crbug.com/462489691): run the Mojo callback with a returned SyncToken.
context_->gpu_sequence()->ScheduleGpuTask(
base::BindOnce(
[](WebNNTensorImpl* self, ExportTensorCallback callback,
ScopedTrace scoped_trace,
mojo::ReportBadMessageCallback bad_message_cb) {
if (self->is_exported()) {
LOG(ERROR)
<< "[WebNN] ExportTensor called on already exported tensor.";
std::move(bad_message_cb).Run(kBadMessageInvalidTensor);
return;
}
// End WebNN access which makes the tensor be exported.
self->ExportTensorImpl(std::move(self->representation_access_),
std::move(callback));
},
base::RetainedRef(this), std::move(mojo_callback_wrapper),
std::move(scoped_trace), GetMojoReceiver().GetBadMessageCallback()));
}
void WebNNTensorImpl::OnDisconnect() {
context_->RemoveWebNNTensorImpl(handle());
}
bool WebNNTensorImpl::ImportTensorInternal() {
DCHECK_CALLED_ON_VALID_SEQUENCE(gpu_sequence_checker_);
if (!representation_) {
LOG(ERROR) << "[WebNN] No representation for tensor to import.";
return false;
}
auto begin_access = [](gpu::WebNNTensorRepresentation* representation,
scoped_refptr<base::SequencedTaskRunner> task_runner) {
return ScopedAccessPtr(representation->BeginScopedAccess().release(),
OnTaskRunnerDeleter(std::move(task_runner)));
};
ScopedAccessPtr access(nullptr, OnTaskRunnerDeleter(nullptr));
// Shared image is thread safe, access the representation on the sequence
// owning the tensor.
if (representation_->is_thread_safe()) {
access = begin_access(representation_.get(), owning_task_runner());
} else {
// Shared image access must be acquired on the main thread. If WebNN runs on
// its own thread, a task is posted to the main thread and waits for
// completion. Otherwise, if WebNN is already running on the main thread,
// access begins immediately.
RunOrPostTaskAndWaitOnSequence(
context_->main_task_runner(),
base::BindOnce(
[](gpu::WebNNTensorRepresentation* representation,
scoped_refptr<base::SequencedTaskRunner> task_runner,
decltype(begin_access) begin_access_cb,
ScopedAccessPtr* out_result) {
*out_result =
begin_access_cb(representation, std::move(task_runner));
},
// Safe to use base::Unretained because we must run or wait for the
// post task to complete and `this` tensor cannot destruct while the
// task is running.
base::Unretained(representation_.get()),
context_->main_task_runner(), begin_access, &access));
}
// Nothing to import if access failed.
if (!access) {
return false;
}
return ImportTensorImpl(std::move(access));
}
// static
void WebNNTensorImpl::RunOrPostTaskAndWaitOnSequence(
scoped_refptr<base::SequencedTaskRunner> target,
base::OnceClosure task) {
if (target->RunsTasksInCurrentSequence()) {
std::move(task).Run();
return;
}
base::ScopedAllowBaseSyncPrimitives allow_wait;
base::WaitableEvent done;
target->PostTask(FROM_HERE, base::BindOnce(
[](base::OnceClosure inner_callback,
base::WaitableEvent* done) {
std::move(inner_callback).Run();
done->Signal();
},
std::move(task), &done));
done.Wait();
}
} // namespace webnn