You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@opendal.apache.org by xu...@apache.org on 2024/06/05 15:42:35 UTC

(opendal) 01/01: refactor(core): Migrate RangeWrite to ConcurrentTasks

This is an automated email from the ASF dual-hosted git repository.

xuanwo pushed a commit to branch refactor-range-write
in repository https://gitbox.apache.org/repos/asf/opendal.git

commit 56f09eac9ad07a8a1899136db9e64fa5a80c2dfb
Author: Xuanwo <gi...@xuanwo.io>
AuthorDate: Wed Jun 5 23:42:10 2024 +0800

    refactor(core): Migrate RangeWrite to ConcurrentTasks
    
    Signed-off-by: Xuanwo <gi...@xuanwo.io>
---
 core/src/raw/oio/write/range_write.rs | 203 +++++++++++++++++-----------------
 core/src/services/gcs/backend.rs      |   3 +-
 2 files changed, 101 insertions(+), 105 deletions(-)

diff --git a/core/src/raw/oio/write/range_write.rs b/core/src/raw/oio/write/range_write.rs
index 66c9d7a39d..95b35aae52 100644
--- a/core/src/raw/oio/write/range_write.rs
+++ b/core/src/raw/oio/write/range_write.rs
@@ -15,14 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::pin::Pin;
 use std::sync::Arc;
-use std::task::Context;
-use std::task::Poll;
 
-use futures::Future;
 use futures::FutureExt;
-use futures::StreamExt;
+use futures::{select, Future};
 
 use crate::raw::*;
 use crate::*;
@@ -89,74 +85,75 @@ pub trait RangeWrite: Send + Sync + Unpin + 'static {
     fn abort_range(&self, location: &str) -> impl Future<Output = Result<()>> + MaybeSend;
 }
 
-/// WritePartResult is the result returned by [`WriteRangeFuture`].
-///
-/// The error part will carries input `(offset, bytes, err)` so caller can retry them.
-type WriteRangeResult = std::result::Result<(), (u64, Buffer, Error)>;
-
-struct WriteRangeFuture(BoxedStaticFuture<WriteRangeResult>);
-
-/// # Safety
-///
-/// wasm32 is a special target that we only have one event-loop for this WriteRangeFuture.
-unsafe impl Send for WriteRangeFuture {}
-
-/// # Safety
-///
-/// We will only take `&mut Self` reference for WriteRangeFuture.
-unsafe impl Sync for WriteRangeFuture {}
-
-impl Future for WriteRangeFuture {
-    type Output = WriteRangeResult;
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        self.get_mut().0.poll_unpin(cx)
-    }
-}
-
-impl WriteRangeFuture {
-    pub fn new<W: RangeWrite>(
-        w: Arc<W>,
-        location: Arc<String>,
-        offset: u64,
-        bytes: Buffer,
-    ) -> Self {
-        let fut = async move {
-            w.write_range(&location, offset, bytes.len() as u64, bytes.clone())
-                .await
-                .map_err(|err| (offset, bytes, err))
-        };
+struct WriteInput<W: RangeWrite> {
+    w: Arc<W>,
+    executor: Executor,
 
-        WriteRangeFuture(Box::pin(fut))
-    }
+    location: Arc<String>,
+    offset: u64,
+    bytes: Buffer,
 }
 
 /// RangeWriter will implements [`oio::Write`] based on range write.
 pub struct RangeWriter<W: RangeWrite> {
+    w: Arc<W>,
+    executor: Executor,
+
     location: Option<Arc<String>>,
     next_offset: u64,
-    buffer: Option<Buffer>,
-    futures: ConcurrentFutures<WriteRangeFuture>,
-
-    w: Arc<W>,
+    cache: Option<Buffer>,
+    tasks: ConcurrentTasks<WriteInput<W>, ()>,
 }
 
 impl<W: RangeWrite> RangeWriter<W> {
     /// Create a new MultipartWriter.
-    pub fn new(inner: W, concurrent: usize) -> Self {
+    pub fn new(inner: W, executor: Option<Executor>, concurrent: usize) -> Self {
+        let executor = executor.unwrap_or_default();
+
         Self {
             w: Arc::new(inner),
-
-            futures: ConcurrentFutures::new(1.max(concurrent)),
-            buffer: None,
+            executor: executor.clone(),
             location: None,
             next_offset: 0,
+            cache: None,
+
+            tasks: ConcurrentTasks::new(executor, concurrent, |input| {
+                Box::pin(async move {
+                    let fut = input.w.write_range(
+                        &input.location,
+                        input.offset,
+                        input.bytes.len() as u64,
+                        input.bytes.clone(),
+                    );
+                    match input.executor.timeout() {
+                        None => {
+                            let result = fut.await;
+                            (input, result)
+                        }
+                        Some(timeout) => {
+                            let result = select! {
+                                result = fut.fuse() => {
+                                    result
+                                }
+                                _ = timeout.fuse() => {
+                                      Err(Error::new(
+                                            ErrorKind::Unexpected, "write range timeout")
+                                                .with_context("offset", input.offset.to_string())
+                                                .set_temporary())
+                                }
+                            };
+                            (input, result)
+                        }
+                    }
+                })
+            }),
         }
     }
 
     fn fill_cache(&mut self, bs: Buffer) -> usize {
         let size = bs.len();
-        assert!(self.buffer.is_none());
-        self.buffer = Some(bs);
+        assert!(self.cache.is_none());
+        self.cache = Some(bs);
         size
     }
 }
@@ -167,7 +164,7 @@ impl<W: RangeWrite> oio::Write for RangeWriter<W> {
             Some(location) => location,
             None => {
                 // Fill cache with the first write.
-                if self.buffer.is_none() {
+                if self.cache.is_none() {
                     let size = self.fill_cache(bs);
                     return Ok(size);
                 }
@@ -179,64 +176,46 @@ impl<W: RangeWrite> oio::Write for RangeWriter<W> {
             }
         };
 
-        loop {
-            if self.futures.has_remaining() {
-                let cache = self.buffer.take().expect("cache must be valid");
-                let offset = self.next_offset;
-                self.next_offset += cache.len() as u64;
-                self.futures.push_back(WriteRangeFuture::new(
-                    self.w.clone(),
-                    location,
-                    offset,
-                    cache,
-                ));
-
-                let size = self.fill_cache(bs);
-                return Ok(size);
-            }
-
-            if let Some(Err((offset, bytes, err))) = self.futures.next().await {
-                self.futures.push_front(WriteRangeFuture::new(
-                    self.w.clone(),
-                    location,
-                    offset,
-                    bytes,
-                ));
-                return Err(err);
-            }
-        }
+        let bytes = self.cache.clone().expect("pending write must exist");
+        let length = bytes.len() as u64;
+        let offset = self.next_offset;
+
+        self.tasks
+            .execute(WriteInput {
+                w: self.w.clone(),
+                executor: self.executor.clone(),
+                location,
+                offset,
+                bytes,
+            })
+            .await?;
+        self.cache = None;
+        self.next_offset += length;
+        let size = self.fill_cache(bs);
+        Ok(size)
     }
 
     async fn close(&mut self) -> Result<()> {
         let Some(location) = self.location.clone() else {
-            let (size, body) = match self.buffer.clone() {
+            let (size, body) = match self.cache.clone() {
                 Some(cache) => (cache.len(), cache),
                 None => (0, Buffer::new()),
             };
             // Call write_once if there is no data in buffer and no location.
-            return self.w.write_once(size as u64, body).await;
+            self.w.write_once(size as u64, body).await?;
+            self.cache = None;
+            return Ok(());
         };
 
-        if !self.futures.is_empty() {
-            while let Some(result) = self.futures.next().await {
-                if let Err((offset, bytes, err)) = result {
-                    self.futures.push_front(WriteRangeFuture::new(
-                        self.w.clone(),
-                        location,
-                        offset,
-                        bytes,
-                    ));
-                    return Err(err);
-                };
-            }
-        }
+        // Make sure all tasks are finished.
+        while self.tasks.next().await.transpose()?.is_some() {}
 
-        if let Some(buffer) = self.buffer.clone() {
+        if let Some(buffer) = self.cache.clone() {
             let offset = self.next_offset;
             self.w
                 .complete_range(&location, offset, buffer.len() as u64, buffer)
                 .await?;
-            self.buffer = None;
+            self.cache = None;
         }
 
         Ok(())
@@ -247,10 +226,9 @@ impl<W: RangeWrite> oio::Write for RangeWriter<W> {
             return Ok(());
         };
 
-        self.futures.clear();
+        self.tasks.clear();
+        self.cache = None;
         self.w.abort_range(&location).await?;
-        // Clean cache when abort_range returns success.
-        self.buffer = None;
         Ok(())
     }
 }
@@ -259,11 +237,13 @@ impl<W: RangeWrite> oio::Write for RangeWriter<W> {
 mod tests {
     use std::collections::HashSet;
     use std::sync::Mutex;
+    use std::time::Duration;
 
     use pretty_assertions::assert_eq;
     use rand::thread_rng;
     use rand::Rng;
     use rand::RngCore;
+    use tokio::time::sleep;
 
     use super::*;
     use crate::raw::oio::Write;
@@ -298,9 +278,14 @@ mod tests {
         }
 
         async fn write_range(&self, _: &str, offset: u64, size: u64, _: Buffer) -> Result<()> {
-            // We will have 50% percent rate for write part to fail.
-            if thread_rng().gen_bool(5.0 / 10.0) {
-                return Err(Error::new(ErrorKind::Unexpected, "I'm a crazy monkey!"));
+            // Add an async sleep here to enforce some pending.
+            sleep(Duration::from_millis(50)).await;
+
+            // We will have 10% percent rate for write part to fail.
+            if thread_rng().gen_bool(1.0 / 10.0) {
+                return Err(
+                    Error::new(ErrorKind::Unexpected, "I'm a crazy monkey!").set_temporary()
+                );
             }
 
             let mut test = self.lock().unwrap();
@@ -318,6 +303,16 @@ mod tests {
         }
 
         async fn complete_range(&self, _: &str, offset: u64, size: u64, _: Buffer) -> Result<()> {
+            // Add an async sleep here to enforce some pending.
+            sleep(Duration::from_millis(50)).await;
+
+            // We will have 10% percent rate for write part to fail.
+            if thread_rng().gen_bool(1.0 / 10.0) {
+                return Err(
+                    Error::new(ErrorKind::Unexpected, "I'm a crazy monkey!").set_temporary()
+                );
+            }
+
             let mut test = self.lock().unwrap();
             test.length += size;
 
@@ -340,7 +335,7 @@ mod tests {
     async fn test_range_writer_with_concurrent_errors() {
         let mut rng = thread_rng();
 
-        let mut w = RangeWriter::new(TestWrite::new(), 8);
+        let mut w = RangeWriter::new(TestWrite::new(), Some(Executor::new()), 200);
         let mut total_size = 0u64;
 
         for _ in 0..1000 {
diff --git a/core/src/services/gcs/backend.rs b/core/src/services/gcs/backend.rs
index 5e9e0a396d..3f1cb93724 100644
--- a/core/src/services/gcs/backend.rs
+++ b/core/src/services/gcs/backend.rs
@@ -434,8 +434,9 @@ impl Access for GcsBackend {
 
     async fn write(&self, path: &str, args: OpWrite) -> Result<(RpWrite, Self::Writer)> {
         let concurrent = args.concurrent();
+        let executor = args.executor().cloned();
         let w = GcsWriter::new(self.core.clone(), path, args);
-        let w = oio::RangeWriter::new(w, concurrent);
+        let w = oio::RangeWriter::new(w, executor, concurrent);
 
         Ok((RpWrite::default(), w))
     }