So when I was checking my profiler, I realized something was causing lots of garbage and after some debugging, it seems that when, and possibly only when, adding 0 to a HashSet that already contains 0 will cause 20B (im guessing B means byte, but who really knows the intention of the creator).
That is a big issue… (at least for me in this case)
It is only if it already contains the 0 already since when doing hash.Clear() and then hash.Add(0) there is no garbage.
I tested it on a few numbers and I only see the issue with number 0.
Edit - Apparently int.MinValue also causes garbage? MaxValue doesnt though. This makes me worried that there are more values that will cause garbage, but I am hoping that 0 and int.MinValue are just special somehow. How would I even test this?
Edit 2 - I did a small test by first adding numbers 0 - 9999998 (and negatives) and then trying to add the same numbers again in update. I only saw 20B being allocated, which tells me that only 1 thing was causing garbage which was 0. Since thats large enough for me, Ill only worry about 0, but maybe 0 and the int.MinValue are just special and produce garbage.
Here is the code causing garbage
using UnityEngine;
using System.Collections.Generic;
public class TestHashContains : MonoBehaviour
{
HashSet<int> hash = new HashSet<int>();
void Update()
{
for(int i = 0; i < 1000; i++)
{
hash.Add(0);
}
}
}
Hmm, it seems to have to do with the hashcode being 0
For example…
using UnityEngine;
using System.Collections.Generic;
public class TestHashContains : MonoBehaviour
{
HashSet<int> hash = new HashSet<int>(IntComparer.defaultComparer);
void Update()
{
for(int i = 0; i < 1000; i++)
{
hash.Add(1);
}
}
}
public class IntComparer : IEqualityComparer<int>
{
public static IntComparer defaultComparer = new IntComparer();
public bool Equals(int x, int y)
{
return x == y;
}
public int GetHashCode(int value)
{
if(value == 0) return 1;
if(value == 1) return 0;
return value;
}
}
With the custom IEqualityComparer, if I swap 0 and 1 hashcodes, then hash.Add(0) no longer causes garbage, but hash.Add(1) is now what is causing garbage.
I guess I can use this to my advantage for a workaround. Since in my case I am checking triangle indices, there will be no negative numbers, so I can make my GetHashCode method like this and all should be fine…
public int GetHashCode(int value)
{
if(value == 0) return -1;
return value;
}
If I am missing something, please let me know.
Edit - I was going to use int.MinValue instead of -1, but apparently int.MinValue also causes garbage? MaxValue doesnt though. This makes me worried that there are more values that will cause garbage, but I am hoping that 0 and int.MinValue are just special somehow. How would I even test this?
Edit 2 - I did a small test by first adding numbers 0 - 9999998 (and negatives) and then trying to add the same numbers again in update. I only saw 20B being allocated, which tells me that only 1 thing was causing garbage which was 0. Since thats large enough for me, Ill only worry about 0, but maybe 0 and the int.MinValue are just special and produce garbage.
This is strange, but Unity’s old Mono version has a bunch of bugs where things that shouldn’t create garbage does.
Should you report it? Probably, but lately, all my bug reports about Mono issues this gets a “We’re postponing this bug until after Mono runtime will be upgraded” reply. If they’re postponing things like the compiler crashing on valid code (which they’re doing), they’re probably going to postpone a bit of garbage.
Report it anyway, if the bug’s around after the upgrade, it’ll probably be handled.
If you look at System.Core dll (where HashSet is located) and check the ‘Add’ method you find this:
/// <summary>
/// Adds the specified element to a set.
/// </summary>
///
/// <returns>
/// true if the element is added to the <see cref="T:System.Collections.Generic.HashSet`1"/> object; false if the element is already present.
/// </returns>
/// <param name="item">The element to add to the set.</param>
public bool Add(T item)
{
int itemHashCode = this.GetItemHashCode(item);
int index1 = (itemHashCode & int.MaxValue) % this.table.Length;
if (this.SlotsContainsAt(index1, itemHashCode, item))
return false;
if (++this.count > this.threshold)
{
this.Resize();
index1 = (itemHashCode & int.MaxValue) % this.table.Length;
}
int index2 = this.empty_slot;
if (index2 == -1)
index2 = this.touched++;
else
this.empty_slot = this.links[index2].Next;
this.links[index2].HashCode = itemHashCode;
this.links[index2].Next = this.table[index1] - 1;
this.table[index1] = index2 + 1;
this.slots[index2] = item;
++this.generation;
return true;
}
So the first thing it does is basically check if ‘item’ is already a member of the HashSet. It does this by getting the hashcode, then checking if it is in any slots.
You’ll notice both of this code does a lot of ‘object’ casting to test if null (the class is generic, so it doesn’t know if it’s dealing with a ref type or a value type).
This is where your garbage is coming from.
Although you should be able to compare a generic like that to null and the compiler optimize that without having to cast… but I’m betting this old version of mono didn’t have that yet or something.
Im a bit confused, if the garbage is coming from the object cast, shouldnt I always see garbage happening? Why is there only garbage for 0 and int.MinValue (might be more, but I think its just those 2).
Is it because of that if statement within the SlotsContainsAt method? Since its using int.MinValue and 0 for comparing stuff, extra code ends up being ran which causes the garbage?
I’ll also make the bug report when I get to my computer later (on tablet atm) and ill post it here too. At least theres a workaround though.
