tried parallel memcpy, didnt' see much

Author: thatstoasty

gojo/bufio/scan.mojo

@@ -286,7 +286,11 @@ struct Scanner[R: io.Reader]():
 # The function is never called with an empty data slice unless at_eof
 # is True. If at_eof is True, however, data may be non-empty and,
 # as always, holds unprocessed text.
-alias SplitFunction = fn (data: List[Byte], at_eof: Bool) -> (Int, List[Byte], Error)
+alias SplitFunction = fn (data: List[Byte], at_eof: Bool) -> (
+    Int,
+    List[Byte],
+    Error,
+)
 
 # # Errors returned by Scanner.
 alias ERR_TOO_LONG = Error("bufio.Scanner: token too long")

gojo/builtins/errors.mojo

@@ -1,5 +1,6 @@
 from sys import exit
 
+
 fn panic[T: Stringable](message: T, code: Int = 1):
     """Panics the program with the given message and exit code.
 

gojo/bytes/buffer.mojo

@@ -1,6 +1,5 @@
 import ..io
 from ..builtins import cap, copy, Byte, panic, index_byte
-from algorithm.memory import parallel_memcpy
 
 
 alias Rune = Int32
@@ -56,7 +55,7 @@ struct Buffer(
     fn __init__(inout self):
         self.capacity = 4096
         self.size = 0
-        self.data = DTypePointer[DType.uint8]().alloc(4096)
+        self.data = DTypePointer[DType.uint8]().alloc(self.capacity)
         self.offset = 0
         self.last_read = OP_INVALID
 
@@ -89,7 +88,11 @@ struct Buffer(
         """Returns a list of bytes holding a copy of the unread portion of the buffer."""
         var copy = UnsafePointer[UInt8]().alloc(self.size)
         memcpy(copy, self.data.offset(self.offset), self.size)
-        return List[UInt8](unsafe_pointer=copy, size=self.size - self.offset, capacity=self.size - self.offset)
+        return List[UInt8](
+            unsafe_pointer=copy,
+            size=self.size - self.offset,
+            capacity=self.size - self.offset,
+        )
 
     @always_inline
     fn _resize(inout self, capacity: Int) -> None:
@@ -100,7 +103,6 @@ struct Buffer(
           capacity: The new capacity of the string builder buffer.
         """
         var new_data = UnsafePointer[UInt8]().alloc(capacity)
-        # parallel_memcpy(new_data, self.data, self.size, 1, 5)
         memcpy(new_data, self.data, self.size)
         self.data.free()
         self.data = new_data
@@ -131,7 +133,9 @@ struct Buffer(
         return StringRef(copy, self.size)
 
     @always_inline
-    fn render(self: Reference[Self]) -> StringSlice[self.is_mutable, self.lifetime]:
+    fn render(
+        self: Reference[Self],
+    ) -> StringSlice[self.is_mutable, self.lifetime]:
         """
         Return a StringSlice view of the data owned by the builder.
         Slightly faster than __str__, 10-20% faster in limited testing.
@@ -237,7 +241,11 @@ struct Buffer(
 
         # Copy the data of the internal buffer from offset to len(buf) into the destination buffer at the given index.
         var bytes_read = copy(
-            target=dest, source=self.data, source_start=self.offset, source_end=self.size, target_start=len(dest)
+            target=dest,
+            source=self.data,
+            source_start=self.offset,
+            source_end=self.size,
+            target_start=len(dest),
         )
         self.offset += bytes_read
 
@@ -324,7 +332,11 @@ struct Buffer(
 
         var copy = UnsafePointer[UInt8]().alloc(end - self.offset)
         memcpy(copy, self.data.offset(self.offset), end - self.offset)
-        var line = List[Byte](unsafe_pointer=copy, size=end - self.offset, capacity=end - self.offset)
+        var line = List[Byte](
+            unsafe_pointer=copy,
+            size=end - self.offset,
+            capacity=end - self.offset,
+        )
         self.offset = end
         self.last_read = OP_READ
 
@@ -529,7 +541,8 @@ struct LegacyBuffer(
     fn try_grow_by_reslice(inout self, n: Int) -> (Int, Bool):
         """Inlineable version of grow for the fast-case where the
         internal buffer only needs to be resliced.
-        It returns the index where bytes should be written and whether it succeeded."""
+        It returns the index where bytes should be written and whether it succeeded.
+        """
         var buffer_already_used = len(self.buf)
 
         if n <= self.buf.capacity - buffer_already_used:

gojo/fmt/fmt.mojo

@@ -77,7 +77,24 @@ fn find_first_verb(s: String, verbs: List[String]) -> String:
     return verb
 
 
-alias BASE10_TO_BASE16 = List[String]("0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f")
+alias BASE10_TO_BASE16 = List[String](
+    "0",
+    "1",
+    "2",
+    "3",
+    "4",
+    "5",
+    "6",
+    "7",
+    "8",
+    "9",
+    "a",
+    "b",
+    "c",
+    "d",
+    "e",
+    "f",
+)
 
 
 fn convert_base10_to_base16(value: Int) -> String:

gojo/net/fd.mojo

@@ -47,7 +47,10 @@ struct FileDescriptor(FileDescriptorBase):
     fn read(inout self, inout dest: List[Byte]) -> (Int, Error):
         """Receive data from the file descriptor and write it to the buffer provided."""
         var bytes_received = recv(
-            self.fd, DTypePointer[DType.uint8](dest.unsafe_ptr()).offset(dest.size), dest.capacity, 0
+            self.fd,
+            DTypePointer[DType.uint8](dest.unsafe_ptr()).offset(dest.size),
+            dest.capacity,
+            0,
         )
         if bytes_received == -1:
             return 0, Error("Failed to receive message from socket.")

gojo/net/socket.mojo

@@ -168,7 +168,11 @@ struct Socket(FileDescriptorBase):
         """
         var their_addr_ptr = UnsafePointer[sockaddr].alloc(1)
         var sin_size = socklen_t(sizeof[socklen_t]())
-        var new_sockfd = accept(self.sockfd.fd, their_addr_ptr, UnsafePointer[socklen_t].address_of(sin_size))
+        var new_sockfd = accept(
+            self.sockfd.fd,
+            their_addr_ptr,
+            UnsafePointer[socklen_t].address_of(sin_size),
+        )
         if new_sockfd == -1:
             raise Error("Failed to accept connection")
 
@@ -302,7 +306,13 @@ struct Socket(FileDescriptorBase):
         """
         var option_value_pointer = UnsafePointer[c_void].address_of(option_value)
         var option_len = sizeof[socklen_t]()
-        var status = setsockopt(self.sockfd.fd, SOL_SOCKET, option_name, option_value_pointer, option_len)
+        var status = setsockopt(
+            self.sockfd.fd,
+            SOL_SOCKET,
+            option_name,
+            option_value_pointer,
+            option_len,
+        )
         if status == -1:
             raise Error("Socket.set_sock_opt failed with status: " + str(status))
 

gojo/strings/builder.mojo

@@ -1,15 +1,14 @@
-from algorithm.functional import vectorize
 import ..io
 from ..builtins import Byte
 
 
-# TODO: Commented out writer until the Span trait issue is fixed. https://github.com/modularml/mojo/issues/2917
 @value
 struct StringBuilder[growth_factor: Float32 = 2](
     Stringable,
     Sized,
-    # io.Writer,
+    io.Writer,
     io.StringWriter,
+    io.ByteWriter,
 ):
     """
     A string builder class that allows for efficient string management and concatenation.
@@ -25,14 +24,14 @@ struct StringBuilder[growth_factor: Float32 = 2](
     builder and appending the strings is not worth the performance gain.
 
     Example:
-      ```
-      from strings.builder import StringBuilder
-
-      var sb = StringBuilder()
-      sb.write_string("Hello ")
-      sb.write_string("World!")
-      print(sb) # Hello World!
-      ```
+                    ```
+                    from strings.builder import StringBuilder
+
+                    var sb = StringBuilder()
+                    sb.write_string("Hello ")
+                    sb.write_string("World!")
+                    print(sb) # Hello World!
+                    ```
     """
 
     var data: DTypePointer[DType.uint8]
@@ -57,7 +56,7 @@ struct StringBuilder[growth_factor: Float32 = 2](
         Returns the length of the string builder.
 
         Returns:
-          The length of the string builder.
+                The length of the string builder.
         """
         return self.size
 
@@ -67,21 +66,23 @@ struct StringBuilder[growth_factor: Float32 = 2](
         Converts the string builder to a string.
 
         Returns:
-          The string representation of the string builder. Returns an empty
-          string if the string builder is empty.
+                The string representation of the string builder. Returns an empty
+                string if the string builder is empty.
         """
         var copy = DTypePointer[DType.uint8]().alloc(self.size)
         memcpy(copy, self.data, self.size)
         return StringRef(copy, self.size)
 
     @always_inline
-    fn render(self: Reference[Self]) -> StringSlice[self.is_mutable, self.lifetime]:
+    fn render(
+        self: Reference[Self],
+    ) -> StringSlice[self.is_mutable, self.lifetime]:
         """
         Return a StringSlice view of the data owned by the builder.
         Slightly faster than __str__, 10-20% faster in limited testing.
 
         Returns:
-          The string representation of the string builder. Returns an empty string if the string builder is empty.
+                The string representation of the string builder. Returns an empty string if the string builder is empty.
         """
         return StringSlice[self.is_mutable, self.lifetime](unsafe_from_utf8_strref=StringRef(self[].data, self[].size))
 
@@ -91,7 +92,7 @@ struct StringBuilder[growth_factor: Float32 = 2](
         Resizes the string builder buffer.
 
         Args:
-          capacity: The new capacity of the string builder buffer.
+                capacity: The new capacity of the string builder buffer.
         """
         var new_data = DTypePointer[DType.uint8]().alloc(capacity)
         memcpy(new_data, self.data, self.size)
@@ -107,7 +108,7 @@ struct StringBuilder[growth_factor: Float32 = 2](
         Appends a byte Span to the builder buffer.
 
         Args:
-          src: The byte array to append.
+                src: The byte array to append.
         """
         if len(src) > self.capacity - self.size:
             var new_capacity = int(self.capacity * growth_factor)
@@ -126,7 +127,7 @@ struct StringBuilder[growth_factor: Float32 = 2](
         Appends a byte Span to the builder buffer.
 
         Args:
-          src: The byte array to append.
+                src: The byte array to append.
         """
         var span = Span(src)
         return self._write(span)
@@ -137,6 +138,11 @@ struct StringBuilder[growth_factor: Float32 = 2](
         Appends a string to the builder buffer.
 
         Args:
-          src: The string to append.
+                src: The string to append.
         """
         return self._write(src.as_bytes_slice())
+
+    @always_inline
+    fn write_byte(inout self, byte: UInt8) -> (Int, Error):
+        var span = Span(List[UInt8](byte))
+        return self._write(span)

gojo/strings/reader.mojo

@@ -3,7 +3,15 @@ from ..builtins import Byte, copy, panic
 
 
 @value
-struct Reader(Sized, io.Reader, io.ReaderAt, io.ByteReader, io.ByteScanner, io.Seeker, io.WriterTo):
+struct Reader(
+    Sized,
+    io.Reader,
+    io.ReaderAt,
+    io.ByteReader,
+    io.ByteScanner,
+    io.Seeker,
+    io.WriterTo,
+):
     """A Reader that implements the [io.Reader], [io.ReaderAt], [io.ByteReader], [io.ByteScanner], [io.Seeker], and [io.WriterTo] traits
     by reading from a string. The zero value for Reader operates like a Reader of an empty string.
     """

gojo/syscall/net.mojo

@@ -462,7 +462,10 @@ fn ntohs(netshort: c_ushort) -> c_ushort:
 
 
 fn inet_ntop(
-    af: c_int, src: DTypePointer[DType.uint8], dst: DTypePointer[DType.uint8], size: socklen_t
+    af: c_int,
+    src: DTypePointer[DType.uint8],
+    dst: DTypePointer[DType.uint8],
+    size: socklen_t,
 ) -> DTypePointer[DType.uint8]:
     """Libc POSIX `inet_ntop` function
     Reference: https://man7.org/linux/man-pages/man3/inet_ntop.3p.html.
@@ -600,7 +603,11 @@ fn getsockopt(
     ](socket, level, option_name, option_value, option_len)
 
 
-fn getsockname(socket: c_int, address: UnsafePointer[sockaddr], address_len: UnsafePointer[socklen_t]) -> c_int:
+fn getsockname(
+    socket: c_int,
+    address: UnsafePointer[sockaddr],
+    address_len: UnsafePointer[socklen_t],
+) -> c_int:
     """Libc POSIX `getsockname` function
     Reference: https://man7.org/linux/man-pages/man3/getsockname.3p.html
     Fn signature: int getsockname(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len).
@@ -619,7 +626,11 @@ fn getsockname(socket: c_int, address: UnsafePointer[sockaddr], address_len: Uns
     ](socket, address, address_len)
 
 
-fn getpeername(sockfd: c_int, addr: UnsafePointer[sockaddr], address_len: UnsafePointer[socklen_t]) -> c_int:
+fn getpeername(
+    sockfd: c_int,
+    addr: UnsafePointer[sockaddr],
+    address_len: UnsafePointer[socklen_t],
+) -> c_int:
     """Libc POSIX `getpeername` function
     Reference: https://man7.org/linux/man-pages/man2/getpeername.2.html
     Fn signature:   int getpeername(int socket, struct sockaddr *restrict addr, socklen_t *restrict address_len).
@@ -660,7 +671,11 @@ fn listen(socket: c_int, backlog: c_int) -> c_int:
     return external_call["listen", c_int, c_int, c_int](socket, backlog)
 
 
-fn accept(socket: c_int, address: UnsafePointer[sockaddr], address_len: UnsafePointer[socklen_t]) -> c_int:
+fn accept(
+    socket: c_int,
+    address: UnsafePointer[sockaddr],
+    address_len: UnsafePointer[socklen_t],
+) -> c_int:
     """Libc POSIX `accept` function
     Reference: https://man7.org/linux/man-pages/man3/accept.3p.html
     Fn signature: int accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len).
@@ -694,7 +709,12 @@ fn connect(socket: c_int, address: UnsafePointer[sockaddr], address_len: socklen
     )
 
 
-fn recv(socket: c_int, buffer: DTypePointer[DType.uint8], length: c_size_t, flags: c_int) -> c_ssize_t:
+fn recv(
+    socket: c_int,
+    buffer: DTypePointer[DType.uint8],
+    length: c_size_t,
+    flags: c_int,
+) -> c_ssize_t:
     """Libc POSIX `recv` function
     Reference: https://man7.org/linux/man-pages/man3/recv.3p.html
     Fn signature: ssize_t recv(int socket, void *buffer, size_t length, int flags).
@@ -709,7 +729,12 @@ fn recv(socket: c_int, buffer: DTypePointer[DType.uint8], length: c_size_t, flag
     ](socket, buffer, length, flags)
 
 
-fn send(socket: c_int, buffer: DTypePointer[DType.uint8], length: c_size_t, flags: c_int) -> c_ssize_t:
+fn send(
+    socket: c_int,
+    buffer: DTypePointer[DType.uint8],
+    length: c_size_t,
+    flags: c_int,
+) -> c_ssize_t:
     """Libc POSIX `send` function
     Reference: https://man7.org/linux/man-pages/man3/send.3p.html
     Fn signature: ssize_t send(int socket, const void *buffer, size_t length, int flags).

gojo/unicode/utf8/string.mojo

@@ -78,7 +78,9 @@ struct UnicodeString(Stringable, Sized):
         return len(self.inner)
 
     @always_inline
-    fn __iter__(self: Reference[Self]) -> _StringIter[self.is_mutable, self.lifetime]:
+    fn __iter__(
+        self: Reference[Self],
+    ) -> _StringIter[self.is_mutable, self.lifetime]:
         return _StringIter(self[].inner)