/// <summary> /// WeakIntern the given InternableString. /// </summary> public string InternableToString(ref InternableString candidate) { if (candidate.Length == 0) { return(string.Empty); } InternResult resultForStatistics = Intern(ref candidate, out string internedString); #if DEBUG string expectedString = candidate.ExpensiveConvertToString(); if (!String.Equals(internedString, expectedString)) { throw new InvalidOperationException(String.Format("Interned string {0} should have been {1}", internedString, expectedString)); } #endif if (_internCallCountsByString != null) { lock (_internCallCountsByString) { switch (resultForStatistics) { case InternResult.FoundInWeakStringCache: _regularInternHits++; break; case InternResult.AddedToWeakStringCache: _regularInternMisses++; break; } _internCallCountsByString.TryGetValue(internedString, out int priorCount); _internCallCountsByString[internedString] = priorCount + 1; if (!candidate.ReferenceEquals(internedString)) { // Reference changed so 'candidate' is now released and should save memory. _internEliminatedStrings++; _internEliminatedChars += candidate.Length; } } } return(internedString); }
/// <summary> /// Main entrypoint of this cache. Tries to look up a string that matches the given internable. If it succeeds, returns /// the string and sets cacheHit to true. If the string is not found, calls ExpensiveConvertToString on the internable, /// adds the resulting string to the cache, and returns it, setting cacheHit to false. /// </summary> /// <param name="internable">The internable describing the string we're looking for.</param> /// <param name="cacheHit">true if match found in cache, false otherwise.</param> /// <returns>A string matching the given internable.</returns> public string GetOrCreateEntry(ref InternableString internable, out bool cacheHit) { int hashCode = internable.GetHashCode(); StringWeakHandle?handle; string? result; // Get the existing handle from the cache and lock it while we're dereferencing it to prevent a race with the Scavenge // method running on another thread and freeing the handle from underneath us. if (_stringsByHashCode.TryGetValue(hashCode, out handle)) { lock (handle) { result = handle.GetString(ref internable); if (result != null) { cacheHit = true; return(result); } // We have the handle but it's not referencing the right string - create the right string and store it in the handle. result = internable.ExpensiveConvertToString(); handle.SetString(result); cacheHit = false; return(result); } } // We don't have the handle in the cache - create the right string, store it in the handle, and add the handle to the cache. result = internable.ExpensiveConvertToString(); handle = new StringWeakHandle(); handle.SetString(result); _stringsByHashCode.TryAdd(hashCode, handle); // Remove unused handles if our heuristic indicates that it would be productive. int scavengeThreshold = _scavengeThreshold; if (_stringsByHashCode.Count >= scavengeThreshold) { // Before we start scavenging set _scavengeThreshold to a high value to effectively lock other threads from // running Scavenge at the same time. if (Interlocked.CompareExchange(ref _scavengeThreshold, int.MaxValue, scavengeThreshold) == scavengeThreshold) { try { // Get rid of unused handles. Scavenge(); } finally { // And do this again when the number of handles reaches double the current after-scavenge number. _scavengeThreshold = _stringsByHashCode.Count * 2; } } } cacheHit = false; return(result); }