[Turbopack] use new backend by default

crates/napi/src/next_api/utils.rs

@@ -1,5 +1,5 @@
 use std::{
-    collections::HashMap, env, future::Future, ops::Deref, path::PathBuf, sync::Arc, time::Duration,
+    collections::HashMap, future::Future, ops::Deref, path::PathBuf, sync::Arc, time::Duration,
 };
 
 use anyhow::{anyhow, Context, Result};
@@ -12,7 +12,9 @@ use serde::Serialize;
 use turbo_tasks::{
     trace::TraceRawVcs, OperationVc, ReadRef, TaskId, TryJoinIterExt, TurboTasks, UpdateInfo, Vc,
 };
-use turbo_tasks_backend::{default_backing_storage, DefaultBackingStorage};
+use turbo_tasks_backend::{
+    default_backing_storage, noop_backing_storage, DefaultBackingStorage, NoopBackingStorage,
+};
 use turbo_tasks_fs::FileContent;
 use turbopack_core::{
     diagnostics::{Diagnostic, DiagnosticContextExt, PlainDiagnostic},
@@ -25,7 +27,7 @@ use crate::util::log_internal_error_and_inform;
 
 #[derive(Clone)]
 pub enum NextTurboTasks {
-    Memory(Arc<TurboTasks<turbo_tasks_memory::MemoryBackend>>),
+    Memory(Arc<TurboTasks<turbo_tasks_backend::TurboTasksBackend<NoopBackingStorage>>>),
     PersistentCaching(
         Arc<TurboTasks<turbo_tasks_backend::TurboTasksBackend<DefaultBackingStorage>>>,
     ),
@@ -108,7 +110,7 @@ impl NextTurboTasks {
 
     pub fn memory_backend(&self) -> Option<&turbo_tasks_memory::MemoryBackend> {
         match self {
-            NextTurboTasks::Memory(turbo_tasks) => Some(turbo_tasks.backend()),
+            NextTurboTasks::Memory(_) => None,
             NextTurboTasks::PersistentCaching(_) => None,
         }
     }
@@ -124,7 +126,7 @@ impl NextTurboTasks {
 pub fn create_turbo_tasks(
     output_path: PathBuf,
     persistent_caching: bool,
-    memory_limit: usize,
+    _memory_limit: usize,
 ) -> Result<NextTurboTasks> {
     Ok(if persistent_caching {
         let dirty_suffix = if crate::build::GIT_CLEAN
@@ -162,11 +164,15 @@ pub fn create_turbo_tasks(
             ),
         ))
     } else {
-        let mut backend = turbo_tasks_memory::MemoryBackend::new(memory_limit);
-        if env::var_os("NEXT_TURBOPACK_PRINT_TASK_INVALIDATION").is_some() {
-            backend.print_task_invalidation(true);
-        }
-        NextTurboTasks::Memory(TurboTasks::new(backend))
+        NextTurboTasks::Memory(TurboTasks::new(
+            turbo_tasks_backend::TurboTasksBackend::new(
+                turbo_tasks_backend::BackendOptions {
+                    storage_mode: None,
+                    ..Default::default()
+                },
+                noop_backing_storage(),
+            ),
+        ))
     })
 }
 

turbopack/crates/turbo-tasks-backend/benches/mod.rs

@@ -7,11 +7,11 @@ pub(crate) mod scope_stress;
 pub(crate) mod stress;
 
 criterion_group!(
-    name = turbo_tasks_memory_stress;
+    name = turbo_tasks_backend_stress;
     config = Criterion::default();
     targets = stress::fibonacci, scope_stress::scope_stress
 );
-criterion_main!(turbo_tasks_memory_stress);
+criterion_main!(turbo_tasks_backend_stress);
 
 pub fn register() {
     turbo_tasks::register();

turbopack/crates/turbopack-tests/Cargo.toml

@@ -30,7 +30,7 @@ turbo-tasks = { workspace = true }
 turbo-tasks-bytes = { workspace = true }
 turbo-tasks-env = { workspace = true }
 turbo-tasks-fs = { workspace = true }
-turbo-tasks-memory = { workspace = true }
+turbo-tasks-backend = { workspace = true }
 turbopack-browser = { workspace = true, features = ["test"] }
 turbopack-cli-utils = { workspace = true }
 turbopack-core = { workspace = true, features = ["issue_path"] }

turbopack/crates/turbopack-tests/tests/execution.rs

@@ -15,13 +15,13 @@ use turbo_tasks::{
     apply_effects, debug::ValueDebugFormat, fxindexmap, trace::TraceRawVcs, Completion,
     NonLocalValue, OperationVc, ResolvedVc, TryJoinIterExt, TurboTasks, Value, Vc,
 };
+use turbo_tasks_backend::{noop_backing_storage, BackendOptions, TurboTasksBackend};
 use turbo_tasks_bytes::stream::SingleValue;
 use turbo_tasks_env::CommandLineProcessEnv;
 use turbo_tasks_fs::{
     json::parse_json_with_source_context, util::sys_to_unix, DiskFileSystem, FileContent,
     FileSystem, FileSystemEntryType, FileSystemPath,
 };
-use turbo_tasks_memory::MemoryBackend;
 use turbopack::{
     ecmascript::TreeShakingMode,
     module_options::{EcmascriptOptionsContext, ModuleOptionsContext, TypescriptTransformOptions},
@@ -168,7 +168,13 @@ async fn run(resource: PathBuf, snapshot_mode: IssueSnapshotMode) -> Result<JsRe
         std::fs::remove_dir_all(&output_path)?;
     }
 
-    let tt = TurboTasks::new(MemoryBackend::default());
+    let tt = TurboTasks::new(TurboTasksBackend::new(
+        BackendOptions {
+            storage_mode: None,
+            ..Default::default()
+        },
+        noop_backing_storage(),
+    ));
     tt.run_once(async move {
         let emit_op =
             run_inner_operation(resource.to_str().unwrap().into(), Value::new(snapshot_mode));

turbopack/crates/turbopack-tests/tests/snapshot.rs

@@ -18,12 +18,12 @@ use turbo_tasks::{
     apply_effects, ReadConsistency, ReadRef, ResolvedVc, TryJoinIterExt, TurboTasks, Value,
     ValueToString, Vc,
 };
+use turbo_tasks_backend::{noop_backing_storage, BackendOptions, TurboTasksBackend};
 use turbo_tasks_env::DotenvProcessEnv;
 use turbo_tasks_fs::{
     json::parse_json_with_source_context, util::sys_to_unix, DiskFileSystem, FileSystem,
     FileSystemPath,
 };
-use turbo_tasks_memory::MemoryBackend;
 use turbopack::{
     ecmascript::{EcmascriptInputTransform, TreeShakingMode},
     module_options::{
@@ -156,7 +156,13 @@ fn test(resource: PathBuf) {
 async fn run(resource: PathBuf) -> Result<()> {
     register();
 
-    let tt = TurboTasks::new(MemoryBackend::default());
+    let tt = TurboTasks::new(TurboTasksBackend::new(
+        BackendOptions {
+            storage_mode: None,
+            ..Default::default()
+        },
+        noop_backing_storage(),
+    ));
     let task = tt.spawn_once_task(async move {
         let emit_op = run_inner_operation(resource.to_str().unwrap().into());
         emit_op.read_strongly_consistent().await?;