static object

Author: youknowone

common/src/refcount.rs

@@ -5,7 +5,7 @@ use crate::atomic::{Ordering::*, PyAtomic, Radium};
 ///
 /// Going above this limit will abort your program (although not
 /// necessarily) at _exactly_ `MAX_REFCOUNT + 1` references.
-const MAX_REFCOUNT: usize = (isize::MAX) as usize;
+const MAX_REFCOUNT: usize = isize::MAX as usize;
 
 pub struct RefCount {
     strong: PyAtomic<usize>,
@@ -18,6 +18,8 @@ impl Default for RefCount {
 }
 
 impl RefCount {
+    const MASK: usize = MAX_REFCOUNT;
+
     pub fn new() -> Self {
         RefCount {
             strong: Radium::new(1),
@@ -33,7 +35,7 @@ impl RefCount {
     pub fn inc(&self) {
         let old_size = self.strong.fetch_add(1, Relaxed);
 
-        if old_size > MAX_REFCOUNT {
+        if old_size & Self::MASK == Self::MASK {
             std::process::abort();
         }
     }
@@ -58,3 +60,19 @@ impl RefCount {
         true
     }
 }
+
+impl RefCount {
+    // move these functions out and give separated type once type range is stabilized
+
+    pub fn leak(&self) {
+        debug_assert!(!self.is_leaked());
+        const BIT_MARKER: usize = (std::isize::MAX as usize) + 1;
+        debug_assert_eq!(BIT_MARKER.count_ones(), 1);
+        debug_assert_eq!(BIT_MARKER.leading_zeros(), 0);
+        self.strong.fetch_add(BIT_MARKER, Relaxed);
+    }
+
+    pub fn is_leaked(&self) -> bool {
+        (self.strong.load(Acquire) as isize) < 0
+    }
+}

vm/src/intern.rs

@@ -2,7 +2,7 @@ use crate::{
     builtins::{PyStr, PyTypeRef},
     common::lock::PyRwLock,
     convert::ToPyObject,
-    Py, PyExact, PyObject, PyObjectRef, PyRef, PyRefExact,
+    AsObject, Py, PyExact, PyObject, PyObjectRef, PyRef, PyRefExact,
 };
 use std::{
     borrow::{Borrow, ToOwned},
@@ -43,14 +43,17 @@ impl StringPool {
             let inserted = zelf.inner.write().insert(cache.clone());
             if inserted {
                 let interned = unsafe { PyStrInterned::borrow_cache(&cache) };
-                // unsafe { interned.as_object().mark_intern() };
+                unsafe { interned.as_object().mark_intern() };
                 interned
             } else {
-                zelf.inner
-                    .read()
-                    .get(cache.as_str())
-                    .map(|cached| unsafe { PyStrInterned::borrow_cache(cached) })
-                    .expect("")
+                unsafe {
+                    PyStrInterned::borrow_cache(
+                        zelf.inner
+                            .read()
+                            .get(cache.as_ref())
+                            .expect("inserted is false"),
+                    )
+                }
             }
         }
         let str_ref = s.into_pyref_exact(typ);
@@ -152,18 +155,20 @@ impl Borrow<PyObject> for PyStrInterned {
     }
 }
 
-impl Deref for PyStrInterned {
-    type Target = Py<PyStr>;
+// NOTE: std::hash::Hash of Self and Self::Borrowed *must* be the same
+// This is ok only because PyObject doesn't implement Hash
+impl std::hash::Hash for PyStrInterned {
     #[inline(always)]
-    fn deref(&self) -> &Self::Target {
-        &self.inner
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.get_id().hash(state)
     }
 }
 
-impl std::hash::Hash for PyStrInterned {
+impl Deref for PyStrInterned {
+    type Target = Py<PyStr>;
     #[inline(always)]
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        std::hash::Hash::hash(&(self as *const _), state)
+    fn deref(&self) -> &Self::Target {
+        &self.inner
     }
 }
 
@@ -177,7 +182,7 @@ impl PartialEq for PyStrInterned {
 impl Eq for PyStrInterned {}
 
 impl AsRef<str> for PyStrInterned {
-    #[inline]
+    #[inline(always)]
     fn as_ref(&self) -> &str {
         self.as_str()
     }
@@ -216,8 +221,12 @@ mod sealed {
 }
 
 /// A sealed marker trait for `DictKey` types that always become an exact instance of `str`
-pub trait Internable: sealed::SealedInternable + ToPyObject + AsRef<Self::Interned> {
-    type Interned: ?Sized + MaybeInterned;
+pub trait Internable
+where
+    Self: sealed::SealedInternable + ToPyObject + AsRef<Self::Interned>,
+    Self::Interned: MaybeInterned,
+{
+    type Interned: ?Sized;
     fn into_pyref_exact(self, str_type: PyTypeRef) -> PyRefExact<PyStr>;
 }
 
@@ -269,6 +278,24 @@ impl MaybeInterned for PyExact<PyStr> {
 impl MaybeInterned for Py<PyStr> {
     #[inline(always)]
     fn as_interned(&self) -> Option<&'static PyStrInterned> {
-        None
+        if self.as_object().is_interned() {
+            Some(unsafe { std::mem::transmute(self) })
+        } else {
+            None
+        }
+    }
+}
+
+impl PyObject {
+    #[inline]
+    pub fn as_interned_str(&self, vm: &crate::VirtualMachine) -> Option<&'static PyStrInterned> {
+        let s: Option<&Py<PyStr>> = self.downcast_ref();
+        if self.is_interned() {
+            s.unwrap().as_interned()
+        } else if let Some(s) = s {
+            vm.ctx.interned_str(s.as_str())
+        } else {
+            None
+        }
     }
 }

vm/src/object/core.rs

@@ -783,6 +783,16 @@ impl PyObject {
         // call drop only when there are no references in scope - stacked borrows stuff
         drop_dealloc(ptr.as_ptr())
     }
+
+    /// # Safety
+    /// This call will make the object live forever.
+    pub(crate) unsafe fn mark_intern(&self) {
+        self.0.ref_count.leak();
+    }
+
+    pub(crate) fn is_interned(&self) -> bool {
+        self.0.ref_count.is_leaked()
+    }
 }
 
 impl Borrow<PyObject> for PyObjectRef {

vm/src/vm/context.rs

@@ -13,7 +13,7 @@ use crate::{
     class::{PyClassImpl, StaticType},
     exceptions,
     function::IntoPyNativeFunc,
-    intern::{Internable, PyStrInterned, StringPool},
+    intern::{Internable, MaybeInterned, PyStrInterned, StringPool},
     object::{PyObjectPayload, PyObjectRef, PyPayload, PyRef},
     types::{PyTypeFlags, PyTypeSlots, TypeZoo},
 };
@@ -119,6 +119,10 @@ impl Context {
         unsafe { self.string_pool.intern(s, self.types.str_type.clone()) }
     }
 
+    pub fn interned_str<S: MaybeInterned + ?Sized>(&self, s: &S) -> Option<&'static PyStrInterned> {
+        self.string_pool.interned(s)
+    }
+
     #[inline(always)]
     pub fn none(&self) -> PyObjectRef {
         self.none.clone().into()