No longer require aligned buffer for shared queue (#3935)

Fixes: #3925

cli/ops/dispatch_json.rs

@@ -32,11 +32,7 @@ fn serialize_result(promise_id: Option<u64>, result: JsonResult) -> Buf {
     Ok(v) => json!({ "ok": v, "promiseId": promise_id }),
     Err(err) => json!({ "err": json_err(err), "promiseId": promise_id }),
   };
-  let mut vec = serde_json::to_vec(&value).unwrap();
+  serde_json::to_vec(&value).unwrap().into_boxed_slice()
-  debug!("JSON response pre-align, len={}", vec.len());
-  // Align to 32bit word, padding with the space character.
-  vec.resize((vec.len() + 3usize) & !3usize, b' ');
-  vec.into_boxed_slice()
 }
 
 #[derive(Deserialize)]

core/isolate.rs

@@ -781,7 +781,7 @@ pub mod tests {
           Mode::Async => {
             assert_eq!(control.len(), 1);
             assert_eq!(control[0], 42);
-            let buf = vec![43u8, 0, 0, 0].into_boxed_slice();
+            let buf = vec![43u8].into_boxed_slice();
             Op::Async(futures::future::ok(buf).boxed())
           }
           Mode::AsyncUnref => {
@@ -790,14 +790,14 @@ pub mod tests {
             let fut = async {
               // This future never finish.
               futures::future::pending::<()>().await;
-              let buf = vec![43u8, 0, 0, 0].into_boxed_slice();
+              let buf = vec![43u8].into_boxed_slice();
               Ok(buf)
             };
             Op::AsyncUnref(fut.boxed())
           }
           Mode::OverflowReqSync => {
             assert_eq!(control.len(), 100 * 1024 * 1024);
-            let buf = vec![43u8, 0, 0, 0].into_boxed_slice();
+            let buf = vec![43u8].into_boxed_slice();
             Op::Sync(buf)
           }
           Mode::OverflowResSync => {
@@ -811,7 +811,7 @@ pub mod tests {
           }
           Mode::OverflowReqAsync => {
             assert_eq!(control.len(), 100 * 1024 * 1024);
-            let buf = vec![43u8, 0, 0, 0].into_boxed_slice();
+            let buf = vec![43u8].into_boxed_slice();
             Op::Async(futures::future::ok(buf).boxed())
           }
           Mode::OverflowResAsync => {
@@ -1007,7 +1007,7 @@ pub mod tests {
         let control = new Uint8Array(100 * 1024 * 1024);
         let response = Deno.core.dispatch(1, control);
         assert(response instanceof Uint8Array);
-        assert(response.length == 4);
+        assert(response.length == 1);
         assert(response[0] == 43);
         assert(asyncRecv == 0);
         "#,
@@ -1046,7 +1046,7 @@ pub mod tests {
         r#"
          let asyncRecv = 0;
          Deno.core.setAsyncHandler(1, (buf) => {
-           assert(buf.byteLength === 4);
+           assert(buf.byteLength === 1);
            assert(buf[0] === 43);
            asyncRecv++;
          });

core/shared_queue.rs

@@ -181,7 +181,6 @@ impl SharedQueue {
       end,
       record.len()
     );
-    assert_eq!(record.len() % 4, 0);
     let index = self.num_records();
     if end > self.bytes().len() || index >= MAX_RECORDS {
       debug!("WARNING the sharedQueue overflowed");
@@ -259,21 +258,21 @@ mod tests {
   #[test]
   fn overflow() {
     let mut q = SharedQueue::new(RECOMMENDED_SIZE);
-    assert!(q.push(0, &alloc_buf(RECOMMENDED_SIZE - 4)));
+    assert!(q.push(0, &alloc_buf(RECOMMENDED_SIZE - 1)));
     assert_eq!(q.size(), 1);
-    assert!(!q.push(0, &alloc_buf(8)));
+    assert!(!q.push(0, &alloc_buf(2)));
     assert_eq!(q.size(), 1);
-    assert!(q.push(0, &alloc_buf(4)));
+    assert!(q.push(0, &alloc_buf(1)));
     assert_eq!(q.size(), 2);
 
     let (_op_id, buf) = q.shift().unwrap();
-    assert_eq!(buf.len(), RECOMMENDED_SIZE - 4);
+    assert_eq!(buf.len(), RECOMMENDED_SIZE - 1);
     assert_eq!(q.size(), 1);
 
-    assert!(!q.push(0, &alloc_buf(4)));
+    assert!(!q.push(0, &alloc_buf(1)));
 
     let (_op_id, buf) = q.shift().unwrap();
-    assert_eq!(buf.len(), 4);
+    assert_eq!(buf.len(), 1);
     assert_eq!(q.size(), 0);
   }
 
@@ -281,19 +280,25 @@ mod tests {
   fn full_records() {
     let mut q = SharedQueue::new(RECOMMENDED_SIZE);
     for _ in 0..MAX_RECORDS {
-      assert!(q.push(0, &alloc_buf(4)))
+      assert!(q.push(0, &alloc_buf(1)))
     }
-    assert_eq!(q.push(0, &alloc_buf(4)), false);
+    assert_eq!(q.push(0, &alloc_buf(1)), false);
     // Even if we shift one off, we still cannot push a new record.
     let _ignored = q.shift().unwrap();
-    assert_eq!(q.push(0, &alloc_buf(4)), false);
+    assert_eq!(q.push(0, &alloc_buf(1)), false);
   }
 
   #[test]
-  #[should_panic]
+  fn allow_any_buf_length() {
-  fn bad_buf_length() {
     let mut q = SharedQueue::new(RECOMMENDED_SIZE);
     // check that `record` that has length not a multiple of 4 will cause panic
+    q.push(0, &alloc_buf(1));
+    q.push(0, &alloc_buf(2));
     q.push(0, &alloc_buf(3));
+    q.push(0, &alloc_buf(4));
+    q.push(0, &alloc_buf(5));
+    q.push(0, &alloc_buf(6));
+    q.push(0, &alloc_buf(7));
+    q.push(0, &alloc_buf(8));
   }
 }