Merge pull request RustPython#2221 from youknowone/tuple-opt

tuple optimization

Author: youknowone

derive/src/pystructseq.rs

@@ -36,7 +36,7 @@ pub(crate) fn impl_pystruct_sequence(
                     self.#field_names,
                     vm,
                 )),*];
-                items.into()
+                ::rustpython_vm::obj::objtuple::PyTuple::_new(items.into_boxed_slice())
             }
         }
     };

vm/src/exceptions.rs

@@ -57,7 +57,7 @@ impl PyBaseException {
             cause: PyRwLock::new(None),
             context: PyRwLock::new(None),
             suppress_context: AtomicCell::new(false),
-            args: PyRwLock::new(PyTuple::from(args).into_ref(vm)),
+            args: PyRwLock::new(PyTupleRef::with_elements(args, &vm.ctx)),
         }
     }
 
@@ -68,7 +68,7 @@ impl PyBaseException {
 
     #[pymethod(name = "__init__")]
     fn init(&self, args: PyFuncArgs, vm: &VirtualMachine) -> PyResult<()> {
-        *self.args.write() = PyTuple::from(args.args).into_ref(vm);
+        *self.args.write() = PyTupleRef::with_elements(args.args, &vm.ctx);
         Ok(())
     }
 
@@ -80,7 +80,7 @@ impl PyBaseException {
     #[pyproperty(setter)]
     fn set_args(&self, args: PyIterable, vm: &VirtualMachine) -> PyResult<()> {
         let args = args.iter(vm)?.collect::<PyResult<Vec<_>>>()?;
-        *self.args.write() = PyTuple::from(args).into_ref(vm);
+        *self.args.write() = PyTupleRef::with_elements(args, &vm.ctx);
         Ok(())
     }
 

vm/src/obj/objbytearray.rs

@@ -17,7 +17,7 @@ use crate::byteslike::PyBytesLike;
 use crate::common::cell::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
 use crate::function::{OptionalArg, OptionalOption};
 use crate::obj::objbytes::PyBytes;
-use crate::obj::objtuple::PyTuple;
+use crate::obj::objtuple::PyTupleRef;
 use crate::pyobject::{
     BorrowValue, Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext,
     PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
@@ -533,14 +533,21 @@ impl PyByteArray {
     }
 
     #[pymethod(magic)]
-    fn reduce_ex(zelf: PyRef<Self>, _proto: usize, vm: &VirtualMachine) -> (PyClassRef, PyTuple) {
+    fn reduce_ex(
+        zelf: PyRef<Self>,
+        _proto: usize,
+        vm: &VirtualMachine,
+    ) -> (PyClassRef, PyTupleRef) {
         Self::reduce(zelf, vm)
     }
 
     #[pymethod(magic)]
-    fn reduce(zelf: PyRef<Self>, vm: &VirtualMachine) -> (PyClassRef, PyTuple) {
+    fn reduce(zelf: PyRef<Self>, vm: &VirtualMachine) -> (PyClassRef, PyTupleRef) {
         let bytes = PyBytes::from(zelf.borrow_value().elements.clone()).into_pyobject(vm);
-        (Self::class(vm), PyTuple::from(vec![bytes]))
+        (
+            Self::class(vm),
+            PyTupleRef::with_elements(vec![bytes], &vm.ctx),
+        )
     }
 }
 

vm/src/obj/objbytes.rs

@@ -15,7 +15,7 @@ use crate::bytesinner::{
 };
 use crate::byteslike::PyBytesLike;
 use crate::function::{OptionalArg, OptionalOption};
-use crate::obj::objtuple::{PyTuple, PyTupleRef};
+use crate::obj::objtuple::PyTupleRef;
 use crate::pyobject::{
     BorrowValue, Either, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyIterable,
     PyObjectRef, PyRef, PyResult, PyValue, TryFromObject,
@@ -452,7 +452,7 @@ impl PyBytes {
             .iter()
             .map(|x| x.into_pyobject(vm))
             .collect();
-        PyTuple::from(param).into_ref(vm)
+        PyTupleRef::with_elements(param, &vm.ctx)
     }
 }
 

vm/src/obj/objlist.rs

@@ -17,7 +17,7 @@ use crate::bytesinner;
 use crate::common::cell::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
 use crate::function::OptionalArg;
 use crate::pyobject::{
-    BorrowValue, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, PyRef,
+    BorrowValue, Either, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, PyRef,
     PyResult, PyValue, TryFromObject, TypeProtocol,
 };
 use crate::sequence::{self, SimpleSeq};
@@ -192,7 +192,12 @@ impl PyList {
 
     #[pymethod(name = "__getitem__")]
     fn getitem(zelf: PyRef<Self>, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        get_item(vm, zelf.as_object(), &zelf.borrow_value(), needle)
+        Ok(
+            match get_item(vm, zelf.as_object(), &zelf.borrow_value(), needle)? {
+                Either::A(obj) => obj,
+                Either::B(vec) => vm.ctx.new_list(vec),
+            },
+        )
     }
 
     #[pymethod(name = "__iter__")]

vm/src/obj/objrange.rs

@@ -6,7 +6,6 @@ use num_traits::{One, Signed, Zero};
 use super::objint::{PyInt, PyIntRef};
 use super::objiter;
 use super::objslice::{PySlice, PySliceRef};
-use super::objtuple::PyTuple;
 use super::objtype::PyClassRef;
 
 use crate::common::hash::PyHash;
@@ -244,12 +243,12 @@ impl PyRange {
     }
 
     #[pymethod(name = "__reduce__")]
-    fn reduce(&self, vm: &VirtualMachine) -> (PyClassRef, PyTuple) {
+    fn reduce(&self, vm: &VirtualMachine) -> (PyClassRef, PyObjectRef) {
         let range_paramters: Vec<PyObjectRef> = vec![&self.start, &self.stop, &self.step]
             .iter()
             .map(|x| x.as_object().clone())
             .collect();
-        let range_paramters_tuple = PyTuple::from(range_paramters);
+        let range_paramters_tuple = vm.ctx.new_tuple(range_paramters);
         (vm.ctx.types.range_type.clone(), range_paramters_tuple)
     }
 

vm/src/obj/objsequence.rs

@@ -4,12 +4,10 @@ use num_bigint::BigInt;
 use num_traits::{One, Signed, ToPrimitive, Zero};
 
 use super::objint::{PyInt, PyIntRef};
-use super::objlist::PyList;
 use super::objsingletons::PyNone;
 use super::objslice::{PySlice, PySliceRef};
-use super::objtuple::PyTuple;
 use crate::function::OptionalArg;
-use crate::pyobject::{BorrowValue, PyObject, PyObjectRef, PyResult, TryFromObject, TypeProtocol};
+use crate::pyobject::{BorrowValue, Either, PyObjectRef, PyResult, TryFromObject, TypeProtocol};
 use crate::vm::VirtualMachine;
 
 pub trait PySliceableSequenceMut {
@@ -465,38 +463,23 @@ pub fn get_item(
     sequence: &PyObjectRef,
     elements: &[PyObjectRef],
     subscript: PyObjectRef,
-) -> PyResult {
+) -> PyResult<Either<PyObjectRef, Vec<PyObjectRef>>> {
     if let Some(i) = subscript.payload::<PyInt>() {
         let value = i.borrow_value().to_isize().ok_or_else(|| {
             vm.new_index_error("cannot fit 'int' into an index-sized integer".to_owned())
         })?;
         let pos_index = get_pos(value, elements.len())
             .ok_or_else(|| vm.new_index_error("Index out of bounds!".to_owned()))?;
-        return Ok(elements[pos_index].clone());
-    }
-
-    let slice = subscript.payload::<PySlice>().ok_or_else(|| {
-        vm.new_type_error(format!(
-            "{} indices must be integers or slices",
-            sequence.lease_class().name
-        ))
-    })?;
-    let items = if sequence.payload::<PyList>().is_some() {
-        PyObject::new(
-            PyList::from(elements.get_slice_items(vm, slice)?),
-            sequence.class(),
-            None,
-        )
-    } else if sequence.payload::<PyTuple>().is_some() {
-        PyObject::new(
-            PyTuple::from(elements.get_slice_items(vm, slice)?),
-            sequence.class(),
-            None,
-        )
+        Ok(Either::A(elements[pos_index].clone()))
     } else {
-        panic!("sequence get_item called for non-sequence")
-    };
-    Ok(items)
+        let slice = subscript.payload::<PySlice>().ok_or_else(|| {
+            vm.new_type_error(format!(
+                "{} indices must be integers or slices",
+                sequence.lease_class().name
+            ))
+        })?;
+        Ok(Either::B(elements.get_slice_items(vm, slice)?))
+    }
 }
 
 //Check if given arg could be used with PySliceableSequence.get_slice_range()

vm/src/obj/objtuple.rs

@@ -6,9 +6,8 @@ use super::objsequence::get_item;
 use super::objtype::PyClassRef;
 use crate::function::OptionalArg;
 use crate::pyobject::{
-    self, BorrowValue, IdProtocol, IntoPyObject,
-    PyArithmaticValue::{self, *},
-    PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue,
+    self, BorrowValue, Either, IdProtocol, IntoPyObject, PyArithmaticValue, PyClassImpl,
+    PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol,
 };
 use crate::sequence::{self, SimpleSeq};
 use crate::slots::{Comparable, Hashable, PyComparisonOp};
@@ -21,7 +20,7 @@ use rustpython_common::hash::PyHash;
 /// If the argument is a tuple, the return value is the same object.
 #[pyclass(module = false, name = "tuple")]
 pub struct PyTuple {
-    elements: Vec<PyObjectRef>,
+    elements: Box<[PyObjectRef]>,
 }
 
 impl fmt::Debug for PyTuple {
@@ -31,12 +30,6 @@ impl fmt::Debug for PyTuple {
     }
 }
 
-impl From<Vec<PyObjectRef>> for PyTuple {
-    fn from(elements: Vec<PyObjectRef>) -> Self {
-        PyTuple { elements }
-    }
-}
-
 impl<'a> BorrowValue<'a> for PyTuple {
     type Borrowed = &'a [PyObjectRef];
 
@@ -77,25 +70,53 @@ impl PyTuple {
 
 pub type PyTupleRef = PyRef<PyTuple>;
 
+impl PyTupleRef {
+    pub(crate) fn with_elements(elements: Vec<PyObjectRef>, ctx: &PyContext) -> Self {
+        if elements.is_empty() {
+            ctx.empty_tuple.clone()
+        } else {
+            let elements = elements.into_boxed_slice();
+            Self::new_ref(PyTuple { elements }, ctx.types.tuple_type.clone(), None)
+        }
+    }
+}
+
 pub(crate) fn get_value(obj: &PyObjectRef) -> &[PyObjectRef] {
     obj.payload::<PyTuple>().unwrap().borrow_value()
 }
 
 #[pyimpl(flags(BASETYPE), with(Hashable, Comparable))]
 impl PyTuple {
+    /// Creating a new tuple with given boxed slice.
+    /// NOTE: for usual case, you probably want to use PyTupleRef::with_elements.
+    /// Calling this function implies trying micro optimization for non-zero-sized tuple.
+    pub(crate) fn _new(elements: Box<[PyObjectRef]>) -> Self {
+        Self { elements }
+    }
+
     #[pymethod(name = "__add__")]
-    fn add(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyArithmaticValue<PyTuple> {
-        if let Some(other) = other.payload_if_subclass::<PyTuple>(vm) {
-            let elements: Vec<_> = self
-                .elements
-                .boxed_iter()
-                .chain(other.borrow_value().boxed_iter())
-                .cloned()
-                .collect();
-            Implemented(elements.into())
-        } else {
-            NotImplemented
-        }
+    fn add(
+        zelf: PyRef<Self>,
+        other: PyObjectRef,
+        vm: &VirtualMachine,
+    ) -> PyArithmaticValue<PyRef<Self>> {
+        let added = other.downcast::<Self>().map(|other| {
+            if other.elements.is_empty() && zelf.class().is(&vm.ctx.types.tuple_type) {
+                zelf
+            } else if zelf.elements.is_empty() && other.class().is(&vm.ctx.types.tuple_type) {
+                other
+            } else {
+                let elements = zelf
+                    .elements
+                    .boxed_iter()
+                    .chain(other.borrow_value().boxed_iter())
+                    .cloned()
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice();
+                Self { elements }.into_ref(vm)
+            }
+        });
+        PyArithmaticValue::from_option(added.ok())
     }
 
     #[pymethod(name = "__bool__")]
@@ -149,16 +170,26 @@ impl PyTuple {
 
     #[pymethod(name = "__mul__")]
     #[pymethod(name = "__rmul__")]
-    fn mul(&self, counter: isize) -> PyTuple {
-        let new_elements: Vec<_> = sequence::seq_mul(&self.elements, counter)
-            .cloned()
-            .collect();
-        new_elements.into()
+    fn mul(&self, counter: isize, vm: &VirtualMachine) -> PyRef<Self> {
+        if self.elements.is_empty() || counter == 0 {
+            vm.ctx.empty_tuple.clone()
+        } else {
+            let elements = sequence::seq_mul(&self.elements, counter)
+                .cloned()
+                .collect::<Vec<_>>()
+                .into_boxed_slice();
+            Self { elements }.into_ref(vm)
+        }
     }
 
     #[pymethod(name = "__getitem__")]
     fn getitem(zelf: PyRef<Self>, needle: PyObjectRef, vm: &VirtualMachine) -> PyResult {
-        get_item(vm, zelf.as_object(), &zelf.elements, needle)
+        Ok(
+            match get_item(vm, zelf.as_object(), &zelf.elements, needle)? {
+                Either::A(obj) => obj,
+                Either::B(vec) => vm.ctx.new_tuple(vec),
+            },
+        )
     }
 
     #[pymethod(name = "index")]
@@ -186,10 +217,10 @@ impl PyTuple {
         cls: PyClassRef,
         iterable: OptionalArg<PyObjectRef>,
         vm: &VirtualMachine,
-    ) -> PyResult<PyTupleRef> {
+    ) -> PyResult<PyRef<Self>> {
         let elements = if let OptionalArg::Present(iterable) = iterable {
             let iterable = if cls.is(&vm.ctx.types.tuple_type) {
-                match iterable.downcast_exact::<PyTuple>(vm) {
+                match iterable.downcast_exact::<Self>(vm) {
                     Ok(tuple) => return Ok(tuple),
                     Err(iterable) => iterable,
                 }
@@ -199,9 +230,10 @@ impl PyTuple {
             vm.extract_elements(&iterable)?
         } else {
             vec![]
-        };
+        }
+        .into_boxed_slice();
 
-        PyTuple::from(elements).into_ref_with_type(vm, cls)
+        Self { elements }.into_ref_with_type(vm, cls)
     }
 }
 

vm/src/obj/objtype.rs

@@ -185,7 +185,7 @@ impl PyClass {
     #[pyproperty(name = "__mro__")]
     fn get_mro(zelf: PyRef<Self>) -> PyTuple {
         let elements: Vec<PyObjectRef> = zelf.iter_mro().map(|x| x.as_object().clone()).collect();
-        PyTuple::from(elements)
+        PyTuple::_new(elements.into_boxed_slice())
     }
 
     #[pyproperty(magic)]