Unverified Commit 2cc54081 authored by Tobias Koppers's avatar Tobias Koppers Committed by GitHub

Turbopack: refactor backend jobs (#83019)

### What?

Use associated types to avoid Box and Any.

* avoids any casting
* avoid extra vec collecting
* avoid cloning lists for parallelization
parent e5311667
......@@ -11,17 +11,16 @@ mod update_output;
use std::{
fmt::{Debug, Formatter},
mem::transmute,
sync::atomic::Ordering,
sync::{Arc, atomic::Ordering},
};
use rustc_hash::FxHashMap;
use serde::{Deserialize, Serialize};
use turbo_tasks::{KeyValuePair, SessionId, TaskId, TurboTasksBackendApi};
use turbo_tasks::{FxIndexMap, KeyValuePair, SessionId, TaskId, TurboTasksBackendApi};
use crate::{
backend::{
BACKEND_JOB_PREFETCH_TASK, OperationGuard, TaskDataCategory, TransientTask,
TurboTasksBackend, TurboTasksBackendInner,
OperationGuard, TaskDataCategory, TransientTask, TurboTasksBackend, TurboTasksBackendInner,
TurboTasksBackendJob,
storage::{SpecificTaskDataCategory, StorageWriteGuard, iter_many},
},
backing_storage::BackingStorage,
......@@ -265,10 +264,11 @@ where
fn schedule_task(&self, mut task: impl TaskGuard + '_) {
if let Some(tasks_to_prefetch) = task.prefetch() {
self.turbo_tasks.schedule_backend_foreground_job(
BACKEND_JOB_PREFETCH_TASK,
Some(Box::new(tasks_to_prefetch)),
);
self.turbo_tasks
.schedule_backend_foreground_job(TurboTasksBackendJob::Prefetch {
data: Arc::new(tasks_to_prefetch),
range: None,
});
}
self.turbo_tasks.schedule(task.id());
}
......@@ -336,7 +336,7 @@ pub trait TaskGuard: Debug {
where
F: for<'a> FnMut(CachedDataItemKey, CachedDataItemValueRef<'a>) -> bool + 'l;
fn invalidate_serialization(&mut self);
fn prefetch(&mut self) -> Option<Vec<(TaskId, bool)>>;
fn prefetch(&mut self) -> Option<FxIndexMap<TaskId, bool>>;
fn is_immutable(&self) -> bool;
}
......@@ -526,15 +526,15 @@ impl<B: BackingStorage> TaskGuard for TaskGuardImpl<'_, B> {
}
}
fn prefetch(&mut self) -> Option<Vec<(TaskId, bool)>> {
fn prefetch(&mut self) -> Option<FxIndexMap<TaskId, bool>> {
if !self.task.state().prefetched() {
self.task.state_mut().set_prefetched(true);
let map = iter_many!(self, OutputDependency { target } => (target, false))
.chain(iter_many!(self, CellDependency { target } => (target.task, true)))
.chain(iter_many!(self, CollectiblesDependency { target } => (target.task, true)))
.collect::<FxHashMap<_, _>>();
.collect::<FxIndexMap<_, _>>();
if map.len() > 16 {
return Some(map.into_iter().collect());
return Some(map);
}
}
None
......
use std::{
any::Any,
borrow::Cow,
error::Error,
fmt::{self, Debug, Display},
......@@ -17,7 +16,6 @@ use serde::{Deserialize, Serialize};
use tracing::Span;
use turbo_rcstr::RcStr;
pub use crate::id::BackendJobId;
use crate::{
RawVc, ReadCellOptions, ReadRef, SharedReference, TaskId, TaskIdSet, TraitRef, TraitTypeId,
TurboTasksPanic, ValueTypeId, VcRead, VcValueTrait, VcValueType,
......@@ -583,10 +581,11 @@ pub trait Backend: Sync + Send {
turbo_tasks: &dyn TurboTasksBackendApi<Self>,
) -> bool;
type BackendJob: Send + 'static;
fn run_backend_job<'a>(
&'a self,
id: BackendJobId,
data: Option<Box<dyn Any + Send>>,
job: Self::BackendJob,
turbo_tasks: &'a dyn TurboTasksBackendApi<Self>,
) -> Pin<Box<dyn Future<Output = ()> + Send + 'a>>;
......
......@@ -115,7 +115,6 @@ macro_rules! define_id {
define_id!(TaskId: u32, derive(Serialize, Deserialize), serde(transparent));
define_id!(ValueTypeId: u32);
define_id!(TraitTypeId: u32);
define_id!(BackendJobId: u32);
define_id!(SessionId: u32, derive(Debug, Serialize, Deserialize), serde(transparent));
define_id!(
LocalTaskId: u32,
......
......@@ -121,8 +121,7 @@ where
}
}
/// An [`IdFactory`], but extended with a free list to allow for id reuse for ids such as
/// [`BackendJobId`][crate::backend::BackendJobId].
/// An [`IdFactory`], but extended with a free list to allow for id reuse.
///
/// If silent untracked re-use of ids is okay, consider using the cheaper
/// [`IdFactory::wrapping_get`] method.
......
......@@ -30,7 +30,7 @@ use crate::{
},
capture_future::CaptureFuture,
event::{Event, EventListener},
id::{BackendJobId, ExecutionId, LocalTaskId, TRANSIENT_TASK_BIT, TraitTypeId},
id::{ExecutionId, LocalTaskId, TRANSIENT_TASK_BIT, TraitTypeId},
id_factory::IdFactoryWithReuse,
macro_helpers::NativeFunction,
magic_any::MagicAny,
......@@ -250,8 +250,8 @@ pub trait TurboTasksBackendApi<B: Backend + 'static>: TurboTasksCallApi + Sync +
unsafe fn reuse_transient_task_id(&self, id: Unused<TaskId>);
fn schedule(&self, task: TaskId);
fn schedule_backend_background_job(&self, id: BackendJobId, data: Option<Box<dyn Any + Send>>);
fn schedule_backend_foreground_job(&self, id: BackendJobId, data: Option<Box<dyn Any + Send>>);
fn schedule_backend_background_job(&self, job: B::BackendJob);
fn schedule_backend_foreground_job(&self, job: B::BackendJob);
fn try_foreground_done(&self) -> Result<(), EventListener>;
fn wait_foreground_done_excluding_own<'a>(
......@@ -1478,16 +1478,16 @@ impl<B: Backend + 'static> TurboTasksBackendApi<B> for TurboTasks<B> {
}
#[track_caller]
fn schedule_backend_background_job(&self, id: BackendJobId, data: Option<Box<dyn Any + Send>>) {
fn schedule_backend_background_job(&self, job: B::BackendJob) {
self.schedule_background_job(move |this| async move {
this.backend.run_backend_job(id, data, &*this).await;
this.backend.run_backend_job(job, &*this).await;
})
}
#[track_caller]
fn schedule_backend_foreground_job(&self, id: BackendJobId, data: Option<Box<dyn Any + Send>>) {
fn schedule_backend_foreground_job(&self, job: B::BackendJob) {
self.schedule_foreground_job(move |this| async move {
this.backend.run_backend_job(id, data, &*this).await;
this.backend.run_backend_job(job, &*this).await;
})
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment