I'm a beginner, and to learn how to use Rust, I decided to try and convert some code in my project from C# to Rust, and see the performance benefits.
I have the following sample C# code:
class Person
{
public string Occupation;
public int Id;
}
class OccupationGroup
{
public string Occupation;
public List<Person> People;
}
class Program
{
static List<OccupationGroup> GroupByOccupation(List<Person> people)
{
var occupations = new List<OccupationGroup>();
var occupationMap = new Dictionary<string, OccupationGroup>();
foreach (Person person in people)
{
if (!occupationMap.TryGetValue(person.Occupation, out var occupation))
{
occupation = new OccupationGroup
{
People = new List<Person>(),
Occupation = person.Occupation
};
occupations.Add(occupation);
occupationMap.Add(person.Occupation, occupation);
}
occupation.People.Add(person);
}
return occupations;
}
static void Main(string[] args)
{
var people = new List<Person>();
people.Add(new Person() { Occupation = "1", Id = -9 });
for (int i = 0; i < 40_000_000; i++)
{
people.Add(new Person() { Occupation = i.ToString(), Id = i });
}
var stopwatch = Stopwatch.StartNew();
var result = GroupByOccupation(people);
Console.WriteLine("Time for C# implementation: {0}", stopwatch.Elapsed.TotalSeconds);
}
}
When trying to convert to Rust, I ran into the problem of there being more than one owner of OccupationGroup - the occupations list and the values of occupationMap.
I tried two different methods to solve it - one is using Rc<RefCell<Occupation>> and Weak<RefCell<Occupation>>, and the other was to make the keys of occupationMap indices of the occupations list (since once an element is added, it isn't altered and will stay in its place).
Here are both solutions:
use std::time::Instant;
use std::rc::Weak;
use std::rc::Rc;
use std::cell::RefCell;
use std::collections::HashMap;
#[derive(Debug, Eq, PartialEq)]
struct Person {
occupation: String,
id: isize
}
#[derive(Debug, Eq, PartialEq)]
struct OccupationGroup<'a> {
occupation: &'a str,
people: Vec<&'a Person>
}
fn group_by_occupation_using_refcell(people: &Vec<Person>) -> Vec<OccupationGroup> {
let mut occupations: Vec<Rc<RefCell<OccupationGroup>>> = vec![];
let mut occupation_map: HashMap<&str, Weak<RefCell<OccupationGroup>>> = HashMap::new();
for person in people {
let occupation_group = occupation_map.entry(person.occupation.as_str()).or_insert_with(|| {
let new_occupation_refcell = Rc::new(RefCell::new(OccupationGroup{
people: vec![],
occupation: &person.occupation
}));
let weak_ref = Rc::downgrade(&new_occupation_refcell);
occupations.push(new_occupation_refcell);
weak_ref
});
occupation_group.upgrade().unwrap().borrow_mut().people.push(person);
}
occupations.into_iter().map(|x| Rc::try_unwrap(x).unwrap().into_inner()).collect()
}
fn group_by_occupation_using_indices(people: &Vec<Person>) -> Vec<OccupationGroup> {
let mut occupations: Vec<OccupationGroup> = vec![];
// map to index instead of ref
let mut occupation_map: HashMap<&str, usize> = HashMap::new();
for person in people {
let occupation_index = *occupation_map.entry(person.occupation.as_str()).or_insert_with(|| {
let new_occupation = OccupationGroup{
people: vec![],
occupation: &person.occupation
};
occupations.push(new_occupation);
occupations.len() - 1
});
occupations[occupation_index].people.push(person);
}
occupations
}
pub fn main() {
let mut people = vec![
Person{occupation: "1".to_string(), id: -9}
];
for i in 0..40_000_000 {
people.push(Person{occupation: i.to_string(), id: i});
}
let now = Instant::now();
let _result = group_by_occupation_using_refcell(&people);
println!("Time for RefCell implementation: {}", now.elapsed().as_secs_f64());
let now = Instant::now();
let _result = group_by_occupation_using_indices(&people);
println!("Time for index implementation: {}", now.elapsed().as_secs_f64());
}
The outputs were as follows:
Time for C# implementation: 35.5179199
Time for RefCell implementation: 53.7812735
Time for index implementation: 62.7572571
I can't understand how come the C# code ran twice as fast.
I assume I'm doing something wrong, but I can't figure out what, so I'd love some help.
Thanks!