Increase user read + write limits (#35974)

GitOrigin-RevId: b96639fca06e5050d16a5623909118f708773fb4

Author: jordanhunt22

crates/common/src/knobs.rs

@@ -210,11 +210,11 @@ pub static HTTP_SERVER_MAX_CONCURRENT_REQUESTS: LazyLock<usize> =
 
 /// Max number of user writes in a transaction
 pub static TRANSACTION_MAX_NUM_USER_WRITES: LazyLock<usize> =
-    LazyLock::new(|| env_config("TRANSACTION_MAX_NUM_USER_WRITES", 8192));
+    LazyLock::new(|| env_config("TRANSACTION_MAX_NUM_USER_WRITES", 16000));
 
 /// Max size of user writes in a transaction, in bytes
 pub static TRANSACTION_MAX_USER_WRITE_SIZE_BYTES: LazyLock<usize> = LazyLock::new(|| {
-    env_config("TRANSACTION_MAX_USER_WRITE_SIZE_BYTES", 1 << 23) // 8 MiB
+    env_config("TRANSACTION_MAX_USER_WRITE_SIZE_BYTES", 1 << 24) // 16 MiB
 });
 
 /// SnapshotManager maintains a bounded time range of versions,
@@ -340,11 +340,11 @@ pub static MAX_REACTOR_CALL_DEPTH: LazyLock<usize> =
 
 /// Number of rows that can be read in a transaction.
 pub static TRANSACTION_MAX_READ_SIZE_ROWS: LazyLock<usize> =
-    LazyLock::new(|| env_config("TRANSACTION_MAX_READ_SIZE_ROWS", 16384));
+    LazyLock::new(|| env_config("TRANSACTION_MAX_READ_SIZE_ROWS", 32000));
 
 /// Number of bytes that can be read in a transaction.
 pub static TRANSACTION_MAX_READ_SIZE_BYTES: LazyLock<usize> = LazyLock::new(|| {
-    env_config("TRANSACTION_MAX_READ_SIZE_BYTES", 1 << 23) // 8 MiB
+    env_config("TRANSACTION_MAX_READ_SIZE_BYTES", 1 << 24) // 16 MiB
 });
 
 /// Maximum number of intervals that can be read in a transaction.

crates/isolate/src/tests/adversarial.rs

@@ -343,9 +343,9 @@ async fn test_iterate_consumed(rt: TestRuntime) -> anyhow::Result<()> {
 #[convex_macro::test_runtime]
 async fn test_reads_too_large(rt: TestRuntime) -> anyhow::Result<()> {
     let t = UdfTest::default(rt).await?;
-    // 16 documents per write * 256KiB per document * 5 writes = 20 MiB, which is
+    // 32 documents per write * 256KiB per document * 5 writes = 40 MiB, which is
     // higher that the limit on reads.
-    let count_per_write = 16.0;
+    let count_per_write = 32.0;
     let mut ids: Vec<ConvexValue> = vec![];
     for _ in 0..5 {
         let more_ids = t
@@ -372,9 +372,9 @@ async fn test_reads_too_large(rt: TestRuntime) -> anyhow::Result<()> {
 #[convex_macro::test_runtime]
 async fn test_reads_large(rt: TestRuntime) -> anyhow::Result<()> {
     let t = UdfTest::default(rt).await?;
-    // 6 documents per write * 256KiB per document * 5 writes = 7 MiB, which is
+    // 12 documents per write * 256KiB per document * 5 writes = 14 MiB, which is
     // close to the limit on reads.
-    let count_per_write = 6.0;
+    let count_per_write = 12.0;
     let mut ids: Vec<ConvexValue> = vec![];
     for _ in 0..5 {
         let more_ids = t
@@ -413,7 +413,7 @@ async fn test_writes_too_big(rt: TestRuntime) -> anyhow::Result<()> {
 #[convex_macro::test_runtime]
 async fn test_writes_big(rt: TestRuntime) -> anyhow::Result<()> {
     let t = UdfTest::default(rt).await?;
-    let count = 30.0;
+    let count = 60.0;
     let mut log_lines = t
         .mutation_log_lines("adversarial:bigWrite", assert_obj!("count" => count))
         .await?;

npm-packages/udf-tests/convex/adversarial.ts

@@ -77,15 +77,15 @@ export const queryLeak = query(async ({ db }) => {
 });
 
 export const queryATon = query(async ({ db }) => {
-  for (let i = 0; i < 15000; i++) {
+  for (let i = 0; i < 30000; i++) {
     for await (const _row of db.query("test")) {
       break;
     }
   }
 });
 
 export const queryTooManyTimes = query(async ({ db }) => {
-  for (let i = 0; i < 5000; i++) {
+  for (let i = 0; i < 10000; i++) {
     await db
       .query("test")
       .withIndex("by_hello", (q) => q.eq("hello", i))
@@ -249,13 +249,13 @@ export const oom = query(async ({ db }) => {
 });
 
 export const tooManyWrites = mutation(async ({ db }) => {
-  for (let i = 0; i < 8193; i++) {
+  for (let i = 0; i < 16002; i++) {
     await db.insert("test", { counter: i });
   }
 });
 
 export const manyWrites = mutation(async ({ db }) => {
-  for (let i = 0; i < 8093; i++) {
+  for (let i = 0; i < 15990; i++) {
     await db.insert("test", { counter: i });
   }
 });