PyO3 · davidhewitt · Nov 26, 2020
diff --git a/Cargo.toml b/Cargo.toml
@@ -32,6 +32,7 @@ hashbrown = { version = "0.9", optional = true }
 assert_approx_eq = "1.1.0"
 trybuild = "1.0.23"
 rustversion = "1.0"
+maplit = "1.0"
 
 [features]
 default = ["macros"]

diff --git a/benches/bench_call.rs b/benches/bench_call.rs
@@ -24,6 +24,7 @@ fn bench_call_0(b: &mut Bencher) {
         let foo = module.getattr("foo").unwrap();
 
         b.iter(|| {
+            let _pool = unsafe { py.new_pool() };
             for _ in 0..1000 {
                 foo.call0().unwrap();
             }
@@ -45,6 +46,7 @@ fn bench_call_method_0(b: &mut Bencher) {
         let foo = module.getattr("Foo").unwrap().call0().unwrap();
 
         b.iter(|| {
+            let _pool = unsafe { py.new_pool() };
             for _ in 0..1000 {
                 foo.call_method0("foo").unwrap();
             }

diff --git a/benches/bench_dict.rs b/benches/bench_dict.rs
@@ -14,6 +14,7 @@ fn iter_dict(b: &mut Bencher) {
     let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
     let mut sum = 0;
     b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
         for (k, _v) in dict.iter() {
             let i: u64 = k.extract().unwrap();
             sum += i;
@@ -29,6 +30,7 @@ fn dict_get_item(b: &mut Bencher) {
     let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
     let mut sum = 0;
     b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
         for i in 0..LEN {
             sum += dict.get_item(i).unwrap().extract::<usize>().unwrap();
         }
@@ -41,7 +43,10 @@ fn extract_hashmap(b: &mut Bencher) {
     let py = gil.python();
     const LEN: usize = 100_000;
     let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
-    b.iter(|| HashMap::<u64, u64>::extract(dict));
+    b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
+        HashMap::<u64, u64>::extract(dict)
+    });
 }
 
 #[bench]
@@ -50,7 +55,10 @@ fn extract_btreemap(b: &mut Bencher) {
     let py = gil.python();
     const LEN: usize = 100_000;
     let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
-    b.iter(|| BTreeMap::<u64, u64>::extract(dict));
+    b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
+        BTreeMap::<u64, u64>::extract(dict)
+    });
 }
 
 #[bench]
@@ -60,5 +68,8 @@ fn extract_hashbrown_map(b: &mut Bencher) {
     let py = gil.python();
     const LEN: usize = 100_000;
     let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
-    b.iter(|| hashbrown::HashMap::<u64, u64>::extract(dict));
+    b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
+        hashbrown::HashMap::<u64, u64>::extract(dict)
+    });
 }
diff --git a/benches/bench_experimental.rs b/benches/bench_experimental.rs
@@ -0,0 +1,214 @@
+#![feature(test)]
+
+extern crate test;
+use pyo3::experimental::objects::{IntoPyDict, PyList, PySet, PyTuple};
+use pyo3::experimental::prelude::*;
+use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
+use test::Bencher;
+
+macro_rules! test_module {
+    ($py:ident, $code:literal) => {
+        PyModule::from_code($py, indoc::indoc!($code), file!(), "test_module")
+            .expect("module creation failed")
+    };
+}
+
+#[bench]
+fn iter_dict(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
+    let mut sum = 0;
+    b.iter(|| {
+        for (k, _v) in dict.iter() {
+            let i: u64 = k.extract().unwrap();
+            sum += i;
+        }
+    });
+}
+
+#[bench]
+fn dict_get_item(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 50_000;
+    let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
+    let dict_ref = &*dict;
+    let mut sum = 0;
+    b.iter(|| {
+        for i in 0..LEN {
+            sum += dict_ref.get_item(i).unwrap().extract::<u64>().unwrap();
+        }
+    });
+}
+
+#[bench]
+fn extract_hashmap(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
+    b.iter(|| HashMap::<u64, u64>::extract(&dict));
+}
+
+#[bench]
+fn extract_btreemap(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
+    b.iter(|| BTreeMap::<u64, u64>::extract(&dict));
+}
+
+#[bench]
+#[cfg(feature = "hashbrown")]
+fn extract_hashbrown_map(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let dict = (0..LEN as u64).map(|i| (i, i * 2)).into_py_dict(py);
+    b.iter(|| hashbrown::HashMap::<u64, u64>::extract(dict));
+}
+
+#[bench]
+fn bench_call_0(b: &mut Bencher) {
+    Python::with_gil(|py| {
+        let module = test_module!(
+            py,
+            r#"
+            def foo(): pass
+        "#
+        );
+
+        let foo = module.getattr("foo").unwrap();
+
+        b.iter(|| {
+            for _ in 0..1000 {
+                foo.call0().unwrap();
+            }
+        });
+    })
+}
+
+#[bench]
+fn bench_call_method_0(b: &mut Bencher) {
+    Python::with_gil(|py| {
+        let module = test_module!(
+            py,
+            r#"
+            class Foo:
+                def foo(self): pass
+        "#
+        );
+
+        let foo = module.getattr("Foo").unwrap().call0().unwrap();
+
+        b.iter(|| {
+            for _ in 0..1000 {
+                foo.call_method0("foo").unwrap();
+            }
+        });
+    })
+}
+
+#[bench]
+fn iter_list(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let list = PyList::new(py, 0..LEN);
+    let mut sum = 0;
+    b.iter(|| {
+        for x in list.iter() {
+            let i: u64 = x.extract().unwrap();
+            sum += i;
+        }
+    });
+}
+
+#[bench]
+fn list_get_item(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 50_000;
+    let list = PyList::new(py, 0..LEN);
+    let mut sum = 0;
+    b.iter(|| {
+        for i in 0..LEN {
+            sum += list.get_item(i as isize).extract::<usize>().unwrap();
+        }
+    });
+}
+
+#[bench]
+fn iter_set(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let set = PySet::new(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
+    let mut sum = 0;
+    b.iter(|| {
+        for x in set.iter() {
+            let i: u64 = x.extract().unwrap();
+            sum += i;
+        }
+    });
+}
+
+#[bench]
+fn extract_hashset(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let set = PySet::new(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
+    b.iter(|| HashSet::<u64>::extract(&set));
+}
+
+#[bench]
+fn extract_btreeset(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let set = PySet::new(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
+    b.iter(|| BTreeSet::<u64>::extract(&set));
+}
+
+#[bench]
+#[cfg(feature = "hashbrown")]
+fn extract_hashbrown_set(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let set = PySet::new(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
+    b.iter(|| hashbrown::HashSet::<u64>::extract(set));
+}
+
+#[bench]
+fn iter_tuple(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 100_000;
+    let tuple = PyTuple::new(py, 0..LEN);
+    let mut sum = 0;
+    b.iter(|| {
+        for x in tuple.iter() {
+            let i: u64 = x.extract().unwrap();
+            sum += i;
+        }
+    });
+}
+
+#[bench]
+fn tuple_get_item(b: &mut Bencher) {
+    let gil = Python::acquire_gil();
+    let py = gil.python();
+    const LEN: usize = 50_000;
+    let tuple = PyTuple::new(py, 0..LEN);
+    let mut sum = 0;
+    b.iter(|| {
+        for i in 0..LEN {
+            sum += tuple.get_item(i).extract::<usize>().unwrap();
+        }
+    });
+}
diff --git a/benches/bench_list.rs b/benches/bench_list.rs
@@ -13,6 +13,7 @@ fn iter_list(b: &mut Bencher) {
     let list = PyList::new(py, 0..LEN);
     let mut sum = 0;
     b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
         for x in list.iter() {
             let i: u64 = x.extract().unwrap();
             sum += i;
@@ -28,6 +29,7 @@ fn list_get_item(b: &mut Bencher) {
     let list = PyList::new(py, 0..LEN);
     let mut sum = 0;
     b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
         for i in 0..LEN {
             sum += list.get_item(i as isize).extract::<usize>().unwrap();
         }

diff --git a/benches/bench_set.rs b/benches/bench_set.rs
@@ -14,6 +14,7 @@ fn iter_set(b: &mut Bencher) {
     let set = PySet::new(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
     let mut sum = 0;
     b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
         for x in set.iter() {
             let i: u64 = x.extract().unwrap();
             sum += i;
@@ -27,7 +28,10 @@ fn extract_hashset(b: &mut Bencher) {
     let py = gil.python();
     const LEN: usize = 100_000;
     let set = PySet::new(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
-    b.iter(|| HashSet::<u64>::extract(set));
+    b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
+        HashSet::<u64>::extract(set)
+    });
 }
 
 #[bench]
@@ -36,7 +40,10 @@ fn extract_btreeset(b: &mut Bencher) {
     let py = gil.python();
     const LEN: usize = 100_000;
     let set = PySet::new(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
-    b.iter(|| BTreeSet::<u64>::extract(set));
+    b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
+        BTreeSet::<u64>::extract(set)
+    });
 }
 
 #[bench]
@@ -46,5 +53,8 @@ fn extract_hashbrown_set(b: &mut Bencher) {
     let py = gil.python();
     const LEN: usize = 100_000;
     let set = PySet::new(py, &(0..LEN).collect::<Vec<_>>()).unwrap();
-    b.iter(|| hashbrown::HashSet::<u64>::extract(set));
+    b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
+        hashbrown::HashSet::<u64>::extract(set)
+    });
 }
diff --git a/benches/bench_tuple.rs b/benches/bench_tuple.rs
@@ -13,6 +13,7 @@ fn iter_tuple(b: &mut Bencher) {
     let tuple = PyTuple::new(py, 0..LEN);
     let mut sum = 0;
     b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
         for x in tuple.iter() {
             let i: u64 = x.extract().unwrap();
             sum += i;
@@ -28,6 +29,7 @@ fn tuple_get_item(b: &mut Bencher) {
     let tuple = PyTuple::new(py, 0..LEN);
     let mut sum = 0;
     b.iter(|| {
+        let _pool = unsafe { py.new_pool() };
         for i in 0..LEN {
             sum += tuple.get_item(i).extract::<usize>().unwrap();
         }

diff --git a/guide/src/experimental_objects.md b/guide/src/experimental_objects.md
@@ -0,0 +1,14 @@
+# Experimental: Objects
+
+Practical differences:
+ - No longer possible to extract `HashMap<&str, &str>` (e.g.) from a PyDict - these strings cannot be guaranteed to be safe to borrow without pyo3 owned references. Instead you should use `HashMap<String, String>`.
+ - Iterators from PyOwned must now be prefixed with &* - e.g. `in set` -> `in &*set`
+ - return values `&'py PyAny` -> `PyOwned<'py, Any>`
+ - Distinction between _types_ `Any` and _objects_ `PyAny`.
+
+ - PyString -> PyStr
+ - PyLong -> PyInt
+
+TODO:
+ - Might want to create a new Python type which returns the new signatures from e.g. pyo3::experimental. This might be too painful.
+ - Probably provide "experimental" forms of all the macros to make the migration possible.
diff --git a/pyo3-derive-backend/src/pymethod.rs b/pyo3-derive-backend/src/pymethod.rs
@@ -481,7 +481,7 @@ fn impl_arg_param(
 
     if spec.is_args(&name) {
         return quote! {
-            let #arg_name = <#ty as pyo3::FromPyObject>::extract(_args.as_ref())
+            let #arg_name = <#ty as pyo3::FromPyObject>::extract(_args)
                 .map_err(#transform_error)?;
         };
     } else if spec.is_kwargs(&name) {