Reimplement Hashtable with Java-style Entry[] array and separate chaining

Replace Rust Arc<Mutex<HashMap>> backing with proper Java fields (table,
count, threshold) and Hashtable$Entry inner class with linked-list
chaining. Implements rehash with capacity old*2+1 and 0.75 load factor.
Remove all Hashtable-specific GC hacks from garbage_collector.rs as
generic field traversal now handles reachability. Add GC test for
Hashtable verifying proper collection of entries.

Author: dlunch

java_runtime/src/classes/java/util.rs

@@ -10,6 +10,7 @@ mod empty_stack_exception;
 mod enumeration;
 mod gregorian_calendar;
 mod hashtable;
+mod hashtable_entry;
 mod properties;
 mod random;
 mod simple_time_zone;
@@ -22,7 +23,7 @@ mod vector;
 
 pub use self::{
     abstract_collection::AbstractCollection, abstract_list::AbstractList, calendar::Calendar, date::Date, dictionary::Dictionary,
-    empty_stack_exception::EmptyStackException, enumeration::Enumeration, gregorian_calendar::GregorianCalendar, hashtable::Hashtable,
+    empty_stack_exception::EmptyStackException, enumeration::Enumeration, gregorian_calendar::GregorianCalendar, hashtable::Hashtable, hashtable_entry::HashtableEntry,
     properties::Properties, random::Random, simple_time_zone::SimpleTimeZone, stack::Stack, time_zone::TimeZone, timer::Timer, timer_task::TimerTask,
     timer_thread::TimerThread, vector::Vector,
 };

java_runtime/src/classes/java/util/hashtable.rs

@@ -1,17 +1,14 @@
-use alloc::{boxed::Box, sync::Arc, vec, vec::Vec};
-use core::mem;
-
-use hashbrown::HashMap;
-use parking_lot::Mutex;
+use alloc::vec;
 
 use java_class_proto::{JavaFieldProto, JavaMethodProto};
-use jvm::{ClassInstance, ClassInstanceRef, Jvm, Result};
+use jvm::{ClassInstanceRef, Jvm, Result};
 
 use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
 
-// I'm too lazy to implement hashmap in java, so i'm leveraging rust hashmap here...
-// We can't use java object as hashmap key as we need `await` to call `equals()`
-type RustHashMap = Arc<Mutex<HashMap<i32, Vec<(Box<dyn ClassInstance>, Box<dyn ClassInstance>)>>>>;
+use super::HashtableEntry;
+
+const DEFAULT_INITIAL_CAPACITY: i32 = 11;
+const DEFAULT_LOAD_FACTOR: f32 = 0.75;
 
 // class java.util.Hashtable
 pub struct Hashtable;
@@ -34,131 +31,207 @@ impl Hashtable {
                 JavaMethodProto::new("get", "(Ljava/lang/Object;)Ljava/lang/Object;", Self::get, Default::default()),
                 JavaMethodProto::new("remove", "(Ljava/lang/Object;)Ljava/lang/Object;", Self::remove, Default::default()),
             ],
-            fields: vec![JavaFieldProto::new("raw", "[B", Default::default())],
+            fields: vec![
+                JavaFieldProto::new("table", "[Ljava/util/Hashtable$Entry;", Default::default()),
+                JavaFieldProto::new("count", "I", Default::default()),
+                JavaFieldProto::new("threshold", "I", Default::default()),
+            ],
             access_flags: Default::default(),
         }
     }
 
     async fn init(jvm: &Jvm, _: &mut RuntimeContext, mut this: ClassInstanceRef<Self>) -> Result<()> {
-        tracing::debug!("java.util.Hashtable::<init>({:?})", &this);
+        tracing::debug!("java.util.Hashtable::<init>({this:?})");
 
         let _: () = jvm.invoke_special(&this, "java/util/Dictionary", "<init>", "()V", ()).await?;
 
-        let rust_hash_map: RustHashMap = Arc::new(Mutex::new(HashMap::new()));
-        jvm.put_rust_object_field(&mut this, "raw", rust_hash_map).await?;
+        let table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", DEFAULT_INITIAL_CAPACITY as _).await?;
+        jvm.put_field(&mut this, "table", "[Ljava/util/Hashtable$Entry;", table).await?;
+        jvm.put_field(&mut this, "count", "I", 0).await?;
+        jvm.put_field(&mut this, "threshold", "I", (DEFAULT_INITIAL_CAPACITY as f32 * DEFAULT_LOAD_FACTOR) as i32).await?;
 
         Ok(())
     }
 
-    // TODO we need to add synchronized
     async fn contains_key(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<bool> {
-        tracing::debug!("java.util.Hashtable::containsKey({:?}, {:?})", &this, &key);
+        tracing::debug!("java.util.Hashtable::containsKey({this:?}, {key:?})");
 
-        let rust_hash_map = Self::get_rust_hashmap(jvm, &this).await?;
         let key_hash: i32 = jvm.invoke_virtual(&key, "hashCode", "()I", ()).await?;
-
-        let vec = rust_hash_map.lock().get(&key_hash).cloned();
-
-        if let Some(x) = vec {
-            for (key, _) in &x {
-                let equals = jvm.invoke_virtual(key, "equals", "(Ljava/lang/Object;)Z", ((*key).clone(),)).await?;
+        let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
+        let table_len = jvm.array_length(&table).await? as i32;
+        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
+
+        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
+        while !entry.is_null() {
+            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
+            if entry_hash == key_hash {
+                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
+                let equals: bool = jvm.invoke_virtual(&entry_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
                 if equals {
                     return Ok(true);
                 }
             }
+            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
         }
+
         Ok(false)
     }
 
-    // TODO we need to add synchronized
     async fn get(jvm: &Jvm, _: &mut RuntimeContext, this: ClassInstanceRef<Self>, key: ClassInstanceRef<Object>) -> Result<ClassInstanceRef<Object>> {
-        tracing::debug!("java.util.Hashtable::get({:?}, {:?})", &this, &key);
+        tracing::debug!("java.util.Hashtable::get({this:?}, {key:?})");
 
-        let rust_hash_map = Self::get_rust_hashmap(jvm, &this).await?;
         let key_hash: i32 = jvm.invoke_virtual(&key, "hashCode", "()I", ()).await?;
-
-        let vec = rust_hash_map.lock().get(&key_hash).cloned();
-
-        if let Some(x) = vec {
-            for (key, value) in &x {
-                let equals = jvm.invoke_virtual(key, "equals", "(Ljava/lang/Object;)Z", ((*key).clone(),)).await?;
+        let table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
+        let table_len = jvm.array_length(&table).await? as i32;
+        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
+
+        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
+        while !entry.is_null() {
+            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
+            if entry_hash == key_hash {
+                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
+                let equals: bool = jvm.invoke_virtual(&entry_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
                 if equals {
-                    return Ok(value.clone().into());
+                    return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
                 }
             }
+            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
         }
 
         Ok(None.into())
     }
 
-    // TODO we need to add synchronized
     async fn remove(
         jvm: &Jvm,
         _: &mut RuntimeContext,
-        this: ClassInstanceRef<Self>,
+        mut this: ClassInstanceRef<Self>,
         key: ClassInstanceRef<Object>,
     ) -> Result<ClassInstanceRef<Object>> {
-        tracing::debug!("java.util.Hashtable::remove({:?}, {:?})", &this, &key);
+        tracing::debug!("java.util.Hashtable::remove({this:?}, {key:?})");
 
-        let rust_hash_map = Self::get_rust_hashmap(jvm, &this).await?;
         let key_hash: i32 = jvm.invoke_virtual(&key, "hashCode", "()I", ()).await?;
-
-        let vec = rust_hash_map.lock().get(&key_hash).cloned();
-
-        if let Some(x) = vec {
-            for (i, (bucket_key, _)) in x.iter().enumerate() {
-                let equals = jvm.invoke_virtual(bucket_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
+        let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
+        let table_len = jvm.array_length(&table).await? as i32;
+        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
+
+        let mut prev: ClassInstanceRef<HashtableEntry> = None.into();
+        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
+
+        while !entry.is_null() {
+            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
+            if entry_hash == key_hash {
+                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
+                let equals: bool = jvm.invoke_virtual(&entry_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
                 if equals {
-                    let (_, old_value) = rust_hash_map.lock().get_mut(&key_hash).unwrap().remove(i);
+                    let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
+                    if prev.is_null() {
+                        jvm.store_array(&mut table, bucket_index, core::iter::once(next)).await?;
+                    } else {
+                        jvm.put_field(&mut prev, "next", "Ljava/util/Hashtable$Entry;", next).await?;
+                    }
 
-                    return Ok(old_value.into());
+                    let count: i32 = jvm.get_field(&this, "count", "I").await?;
+                    jvm.put_field(&mut this, "count", "I", count - 1).await?;
+
+                    return jvm.get_field(&entry, "value", "Ljava/lang/Object;").await;
                 }
             }
+            prev = entry;
+            entry = jvm.get_field(&prev, "next", "Ljava/util/Hashtable$Entry;").await?;
         }
 
         Ok(None.into())
     }
 
-    // TODO we need to add synchronized
     async fn put(
         jvm: &Jvm,
         _: &mut RuntimeContext,
-        this: ClassInstanceRef<Self>,
+        mut this: ClassInstanceRef<Self>,
         key: ClassInstanceRef<Object>,
         value: ClassInstanceRef<Object>,
     ) -> Result<ClassInstanceRef<Object>> {
-        tracing::debug!("java.util.Hashtable::put({:?}, {:?}, {:?})", &this, &key, &value);
+        tracing::debug!("java.util.Hashtable::put({this:?}, {key:?}, {value:?})");
 
-        let rust_hash_map = Self::get_rust_hashmap(jvm, &this).await?;
         let key_hash: i32 = jvm.invoke_virtual(&key, "hashCode", "()I", ()).await?;
-
-        let vec = {
-            let mut rust_hash_map = rust_hash_map.lock();
-            if !rust_hash_map.contains_key(&key_hash) {
-                rust_hash_map.insert(key_hash, Vec::new());
+        let mut table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
+        let table_len = jvm.array_length(&table).await? as i32;
+        let bucket_index = ((key_hash & 0x7FFFFFFF) % table_len) as usize;
+
+        let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
+        while !entry.is_null() {
+            let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
+            if entry_hash == key_hash {
+                let entry_key: ClassInstanceRef<Object> = jvm.get_field(&entry, "key", "Ljava/lang/Object;").await?;
+                let equals: bool = jvm.invoke_virtual(&entry_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
+                if equals {
+                    let old_value: ClassInstanceRef<Object> = jvm.get_field(&entry, "value", "Ljava/lang/Object;").await?;
+                    jvm.put_field(&mut entry, "value", "Ljava/lang/Object;", value).await?;
+                    return Ok(old_value);
+                }
             }
+            entry = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
+        }
+
+        let count: i32 = jvm.get_field(&this, "count", "I").await?;
+        let threshold: i32 = jvm.get_field(&this, "threshold", "I").await?;
+
+        if count >= threshold {
+            Self::rehash(jvm, &mut this).await?;
+            table = jvm.get_field(&this, "table", "[Ljava/util/Hashtable$Entry;").await?;
+            let new_table_len = jvm.array_length(&table).await? as i32;
+            let new_bucket_index = ((key_hash & 0x7FFFFFFF) % new_table_len) as usize;
+
+            let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, new_bucket_index, 1).await?.into_iter().next().unwrap();
+            let new_entry = jvm
+                .new_class(
+                    "java/util/Hashtable$Entry",
+                    "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
+                    (key_hash, key, value, existing),
+                )
+                .await?;
+            jvm.store_array(&mut table, new_bucket_index, core::iter::once(new_entry)).await?;
+        } else {
+            let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&table, bucket_index, 1).await?.into_iter().next().unwrap();
+            let new_entry = jvm
+                .new_class(
+                    "java/util/Hashtable$Entry",
+                    "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V",
+                    (key_hash, key, value, existing),
+                )
+                .await?;
+            jvm.store_array(&mut table, bucket_index, core::iter::once(new_entry)).await?;
+        }
 
-            rust_hash_map.get(&key_hash).cloned().unwrap()
-        };
+        jvm.put_field(&mut this, "count", "I", count + 1).await?;
+
+        Ok(None.into())
+    }
 
-        for (i, (bucket_key, _)) in vec.iter().enumerate() {
-            let equals = jvm.invoke_virtual(bucket_key, "equals", "(Ljava/lang/Object;)Z", (key.clone(),)).await?;
-            if equals {
-                let mut rust_hash_map = rust_hash_map.lock();
-                let vec = rust_hash_map.get_mut(&key_hash).unwrap();
+    async fn rehash(jvm: &Jvm, this: &mut ClassInstanceRef<Self>) -> Result<()> {
+        let old_table = jvm.get_field(this, "table", "[Ljava/util/Hashtable$Entry;").await?;
+        let old_capacity = jvm.array_length(&old_table).await?;
+        let new_capacity = old_capacity * 2 + 1;
 
-                let (_, old_value) = mem::replace(&mut vec[i], (key.into(), value.into()));
+        let mut new_table = jvm.instantiate_array("Ljava/util/Hashtable$Entry;", new_capacity).await?;
 
-                return Ok(old_value.into());
+        for i in 0..old_capacity {
+            let mut entry: ClassInstanceRef<HashtableEntry> = jvm.load_array(&old_table, i, 1).await?.into_iter().next().unwrap();
+            while !entry.is_null() {
+                let next: ClassInstanceRef<HashtableEntry> = jvm.get_field(&entry, "next", "Ljava/util/Hashtable$Entry;").await?;
+                let entry_hash: i32 = jvm.get_field(&entry, "hash", "I").await?;
+                let new_index = ((entry_hash & 0x7FFFFFFF) % new_capacity as i32) as usize;
+
+                let existing: ClassInstanceRef<HashtableEntry> = jvm.load_array(&new_table, new_index, 1).await?.into_iter().next().unwrap();
+                jvm.put_field(&mut entry, "next", "Ljava/util/Hashtable$Entry;", existing).await?;
+                jvm.store_array(&mut new_table, new_index, core::iter::once(entry)).await?;
+
+                entry = next;
             }
         }
 
-        rust_hash_map.lock().get_mut(&key_hash).unwrap().push((key.into(), value.into()));
-
-        Ok(None.into())
-    }
+        jvm.put_field(this, "table", "[Ljava/util/Hashtable$Entry;", new_table).await?;
+        jvm.put_field(this, "threshold", "I", (new_capacity as f32 * DEFAULT_LOAD_FACTOR) as i32).await?;
 
-    async fn get_rust_hashmap(jvm: &Jvm, this: &ClassInstanceRef<Self>) -> Result<RustHashMap> {
-        jvm.get_rust_object_field(this, "raw").await
+        Ok(())
     }
 }

java_runtime/src/classes/java/util/hashtable_entry.rs

@@ -0,0 +1,48 @@
+use alloc::vec;
+
+use java_class_proto::{JavaFieldProto, JavaMethodProto};
+use jvm::{ClassInstanceRef, Jvm, Result};
+
+use crate::{RuntimeClassProto, RuntimeContext, classes::java::lang::Object};
+
+// class java.util.Hashtable$Entry
+pub struct HashtableEntry;
+
+impl HashtableEntry {
+    pub fn as_proto() -> RuntimeClassProto {
+        RuntimeClassProto {
+            name: "java/util/Hashtable$Entry",
+            parent_class: Some("java/lang/Object"),
+            interfaces: vec![],
+            methods: vec![JavaMethodProto::new("<init>", "(ILjava/lang/Object;Ljava/lang/Object;Ljava/util/Hashtable$Entry;)V", Self::init, Default::default())],
+            fields: vec![
+                JavaFieldProto::new("hash", "I", Default::default()),
+                JavaFieldProto::new("key", "Ljava/lang/Object;", Default::default()),
+                JavaFieldProto::new("value", "Ljava/lang/Object;", Default::default()),
+                JavaFieldProto::new("next", "Ljava/util/Hashtable$Entry;", Default::default()),
+            ],
+            access_flags: Default::default(),
+        }
+    }
+
+    async fn init(
+        jvm: &Jvm,
+        _: &mut RuntimeContext,
+        mut this: ClassInstanceRef<Self>,
+        hash: i32,
+        key: ClassInstanceRef<Object>,
+        value: ClassInstanceRef<Object>,
+        next: ClassInstanceRef<HashtableEntry>,
+    ) -> Result<()> {
+        tracing::debug!("java.util.Hashtable$Entry::<init>({this:?}, {hash:?}, {key:?}, {value:?}, {next:?})");
+
+        let _: () = jvm.invoke_special(&this, "java/lang/Object", "<init>", "()V", ()).await?;
+
+        jvm.put_field(&mut this, "hash", "I", hash).await?;
+        jvm.put_field(&mut this, "key", "Ljava/lang/Object;", key).await?;
+        jvm.put_field(&mut this, "value", "Ljava/lang/Object;", value).await?;
+        jvm.put_field(&mut this, "next", "Ljava/util/Hashtable$Entry;", next).await?;
+
+        Ok(())
+    }
+}

java_runtime/src/loader.rs

@@ -80,6 +80,7 @@ pub fn get_runtime_class_proto(name: &str) -> Option<RuntimeClassProto> {
         crate::classes::java::util::Enumeration::as_proto(),
         crate::classes::java::util::GregorianCalendar::as_proto(),
         crate::classes::java::util::Hashtable::as_proto(),
+        crate::classes::java::util::HashtableEntry::as_proto(),
         crate::classes::java::util::Properties::as_proto(),
         crate::classes::java::util::Random::as_proto(),
         crate::classes::java::util::SimpleTimeZone::as_proto(),