public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
interner.Intern(ref _event);
interner.Intern(ref _source);
interner.Intern(ref _type);
interner.Intern(ref _method);
interner.Intern(ref _message);
interner.Intern(_exception);
interner.Intern(_details);
if (_parameters != null)
{
foreach (EventParameter param in _parameters)
{
param.Intern(interner);
}
}
}
protected override StackSourceCallStackIndex InternCallerStack(StackSourceFrameIndex frameIndex, StackSourceCallStackIndex stackIndex)
{
lock (internCallStackLock)
{
return(Interner.CallStackIntern(frameIndex, stackIndex));
}
}
public void Read(TextReader reader)
{
var sample = new StackSourceSample(this);
sample.Metric = 1;
for (; ;)
{
var line = reader.ReadLine();
if (line == null)
{
break;
}
if (StackForLine != null)
{
sample.StackIndex = StackForLine(Interner, line);
}
else
{
// Form the stack for this entry (trivial one element stack)
var frameIndex = Interner.FrameIntern(line);
sample.StackIndex = Interner.CallStackIntern(frameIndex, StackSourceCallStackIndex.Invalid);
}
if (sample.StackIndex != StackSourceCallStackIndex.Invalid)
{
AddSample(sample);
}
}
Interner.DoneInterning();
}
static SiloAddress()
{
siloAddressInterningCache = new Interner <SiloAddress, SiloAddress>(INTERN_CACHE_INITIAL_SIZE, internCacheCleanupInterval);
var sa = new SiloAddress(new IPEndPoint(0, 0), 0);
Zero = siloAddressInterningCache.Intern(sa, sa);
}
public CancellationSourcesExtension(ILoggerFactory loggerFactory)
{
_cancellationTokens = new Interner <Guid, GrainCancellationToken>(
_defaultInternerCollectionSize,
_cleanupFrequency);
_logger = loggerFactory.CreateLogger <CancellationSourcesExtension>();
}
public void ID_Intern_derived_class()
{
Interner <int, A> interner = new Interner <int, A>();
var obj1 = new A();
var obj2 = new B();
var obj3 = new B();
var r1 = interner.InternAndUpdateWithMoreDerived(1, obj1);
Assert.AreEqual(obj1, r1, "Objects should be equal");
Assert.AreSame(obj1, r1, "Objects should be same / intern'ed");
var r2 = interner.InternAndUpdateWithMoreDerived(2, obj2);
Assert.AreEqual(obj2, r2, "Objects should be equal");
Assert.AreSame(obj2, r2, "Objects should be same / intern'ed");
// Interning should not replace instances of same class
var r3 = interner.InternAndUpdateWithMoreDerived(2, obj3);
Assert.AreSame(obj2, r3, "Interning should return previous object");
Assert.AreNotSame(obj3, r3, "Interning should not replace previous object of same class");
// Interning should return instances of most derived class
var r4 = interner.InternAndUpdateWithMoreDerived(1, obj2);
Assert.AreSame(obj2, r4, "Interning should return most derived object");
Assert.AreNotSame(obj1, r4, "Interning should replace cached instances of less derived object");
// Interning should not return instances of less derived class
var r5 = interner.InternAndUpdateWithMoreDerived(2, obj1);
Assert.AreNotSame(obj1, r5, "Interning should not return less derived object");
Assert.AreSame(obj2, r5, "Interning should return previously cached instances of more derived object");
}
// TODO is making this public a hack?
public StackSourceFrameIndex GetFrameIndex(CodeAddressIndex codeAddressIndex, out bool isReasonableTopStack)
{
isReasonableTopStack = false;
string moduleName = "?";
ModuleFileIndex moduleIdx = m_log.CodeAddresses.ModuleFileIndex(codeAddressIndex);
if (moduleIdx != Diagnostics.Tracing.ModuleFileIndex.Invalid)
{
moduleName = m_log.ModuleFiles[moduleIdx].FilePath;
if (moduleName.EndsWith("ntdll.dll", StringComparison.OrdinalIgnoreCase))
{
isReasonableTopStack = true;
}
}
var internedModule = Interner.ModuleIntern(moduleName);
string methodName = "?";
var methodIdx = m_log.CodeAddresses.MethodIndex(codeAddressIndex);
if (methodIdx != MethodIndex.Invalid)
{
methodName = m_log.CodeAddresses.Methods.FullMethodName(methodIdx);
}
else if (ShowUnknownAddressses)
{
methodName = "0x" + m_log.CallStacks.CodeAddresses.Address(codeAddressIndex).ToString("x");
}
var internedFrame = Interner.FrameIntern(methodName, internedModule);
return(internedFrame);
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
// Build a new collection using interned keys and values and then replace the underlying collection
// with the new one - should be thread-safe without locking.
if (_cookies.Count > 0)
{
var newCookies = new List <HttpCookieDetail>();
foreach (var cookie in _cookies)
{
var newCookie = cookie.Clone();
newCookie.Intern(interner);
newCookies.Add(newCookie);
}
_cookies = newCookies;
}
}
public void ID_Intern_FindOrCreate_derived_class()
{
Interner <int, A> interner = new Interner <int, A>();
var obj1 = new A();
var obj2 = new B();
var obj3 = new B();
var r1 = interner.FindOrCreate(1, _ => obj1);
Assert.Equal(obj1, r1); // Objects should be equal
Assert.Same(obj1, r1); // Objects should be same / intern'ed
var r2 = interner.FindOrCreate(2, _ => obj2);
Assert.Equal(obj2, r2); // Objects should be equal
Assert.Same(obj2, r2); // Objects should be same / intern'ed
// FindOrCreate should not replace instances of same class
var r3 = interner.FindOrCreate(2, _ => obj3);
Assert.Same(obj2, r3); // FindOrCreate should return previous object
Assert.NotSame(obj3, r3); // FindOrCreate should not replace previous object of same class
// FindOrCreate should not replace cached instances with instances of most derived class
var r4 = interner.FindOrCreate(1, _ => obj2);
Assert.Same(obj1, r4); // FindOrCreate return previously cached object
Assert.NotSame(obj2, r4); // FindOrCreate should not replace previously cached object
// FindOrCreate should not replace cached instances with instances of less derived class
var r5 = interner.FindOrCreate(2, _ => obj1);
Assert.NotSame(obj1, r5); // FindOrCreate should not replace previously cached object
Assert.Same(obj2, r5); // FindOrCreate return previously cached object
}
public void ID_Intern_FindOrCreate_derived_class()
{
Interner <int, A> interner = new Interner <int, A>();
var obj1 = new A();
var obj2 = new B();
var obj3 = new B();
var r1 = interner.FindOrCreate(1, () => obj1);
Assert.AreEqual(obj1, r1, "Objects should be equal");
Assert.AreSame(obj1, r1, "Objects should be same / intern'ed");
var r2 = interner.FindOrCreate(2, () => obj2);
Assert.AreEqual(obj2, r2, "Objects should be equal");
Assert.AreSame(obj2, r2, "Objects should be same / intern'ed");
// FindOrCreate should not replace instances of same class
var r3 = interner.FindOrCreate(2, () => obj3);
Assert.AreSame(obj2, r3, "FindOrCreate should return previous object");
Assert.AreNotSame(obj3, r3, "FindOrCreate should not replace previous object of same class");
// FindOrCreate should not replace cached instances with instances of most derived class
var r4 = interner.FindOrCreate(1, () => obj2);
Assert.AreSame(obj1, r4, "FindOrCreate return previously cached object");
Assert.AreNotSame(obj2, r4, "FindOrCreate should not replace previously cached object");
// FindOrCreate should not replace cached instances with instances of less derived class
var r5 = interner.FindOrCreate(2, () => obj1);
Assert.AreNotSame(obj1, r5, "FindOrCreate should not replace previously cached object");
Assert.AreSame(obj2, r5, "FindOrCreate return previously cached object");
}
public StackSourceFrameIndex GetFrameIndexForName(string frameName, StackSourceModuleIndex moduleIdx = StackSourceModuleIndex.Invalid)
{
if (moduleIdx == StackSourceModuleIndex.Invalid)
{
moduleIdx = m_emptyModuleIdx;
}
return(Interner.FrameIntern(frameName, moduleIdx));
}
public StackSourceCallStackIndex GetCallStackForThread(TraceThread thread)
{
var processStack = GetCallStackForProcess(thread.Process);
var threadName = "Thread (" + thread.ThreadID + ")";
var internedThreadFrame = Interner.FrameIntern(threadName, m_emptyModuleIdx);
var threadStack = Interner.CallStackIntern(internedThreadFrame, processStack);
return(threadStack);
}
// Advanced usage
public StackSourceCallStackIndex GetCallStackForProcess(TraceProcess process)
{
string ptrSize = process.Is64Bit ? "64" : "32";
var processName = "Process" + ptrSize + " " + process.Name + " (" + process.ProcessID + ")";
var internedProcessFrame = Interner.FrameIntern(processName, m_emptyModuleIdx);
var processStack = Interner.CallStackIntern(internedProcessFrame, StackSourceCallStackIndex.Invalid);
return(processStack);
}
public SynchronizedInterner(Interner <T> delegate_, object mutex)
{
if (delegate_ == null)
{
throw new ArgumentNullException();
}
this.delegate_ = delegate_;
this.mutex = mutex;
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
m_appDomainName = interner.Intern(m_appDomainName);
}
/// <summary>
/// Note that on windows, lastAccessTime does not really work (acts like lastWriteTime). They turned it off for efficiency reasons.
/// </summary>
public FileSizeStackSource(string directoryPath, TextWriter log, bool useWriteTime = true)
{
m_useWriteTime = useWriteTime;
m_nowUtc = DateTime.UtcNow;
m_log = log;
// Make the full path the root node.
var stackBase = Interner.CallStackIntern(Interner.FrameIntern("DIR: " + Path.GetFullPath(directoryPath)), StackSourceCallStackIndex.Invalid);
AddSamplesForDirectory(directoryPath, stackBase);
Interner.DoneInterning();
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
interner.Intern(ref _stackTrace);
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
_processName = interner.Intern(_processName);
_machineName = interner.Intern(_machineName);
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
_request.Intern(interner);
_session.Intern(interner);
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
_key = interner.Intern(_key);
_values = interner.Intern(_values);
}
public void Intern(Interner interner)
{
interner.Intern(_type);
interner.Intern(ref _helpLink);
interner.Intern(ref _hResult);
interner.Intern(ref _message);
interner.Intern(ref _source);
interner.Intern(ref _stackTrace);
interner.Intern(ref _targetSite);
interner.Intern(ref _toString);
_properties = interner.Intern(_properties);
interner.Intern(_innerException);
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
m_processUserName = interner.Intern(m_processUserName);
m_authenticationType = interner.Intern(m_authenticationType);
m_userName = interner.Intern(m_userName);
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
interner.Intern(ref m_name);
interner.Intern(ref m_class);
interner.TryIntern(ref m_value);
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
interner.Intern(ref _hostName);
interner.Intern(ref _hostAddress);
interner.Intern(ref _agent);
}
public void Intern(Interner interner)
{
const string method = "Intern";
if (interner == null)
{
throw new NullParameterException(GetType(), method, "interner");
}
_domain = interner.Intern(_domain);
_name = interner.Intern(_name);
_path = interner.Intern(_path);
}
protected override StackSourceFrameIndex InternFrame(string displayName)
{
StackSourceFrameIndex frameIndex;
if (!frames.TryGetValue(displayName, out frameIndex))
{
lock (internFrameLock)
{
frameIndex = Interner.FrameIntern(displayName);
frames[displayName] = frameIndex;
}
}
return(frameIndex);
}
internal static string[] InternStringArray(Interner interner, string[] input)
{
if (input == null || input.Length == 0)
{
return(null);
}
else if (interner == null)
{
return((string[])input.Clone());
}
else
{
return(interner.Intern(input));
}
}
public void ID_Interning_string_equals()
{
using var interner = new Interner <string, string>();
const string str = "1";
string r1 = interner.FindOrCreate("1", _ => str);
string r2 = interner.FindOrCreate("1", _ => null); // Should always be found
Assert.Equal(r1, r2); // 1: Objects should be equal
Assert.Same(r1, r2); // 2: Objects should be same / intern'ed
// Round-trip through Serializer
string r3 = this.environment.Serializer.Deserialize <string>(environment.Serializer.SerializeToArray(r1));
Assert.Equal(r1, r3); // 3: Should be equal
Assert.Equal(r2, r3); // 4: Should be equal
}
public void ID_Interning_string_equals()
{
Interner <string, string> interner = new Interner <string, string>();
const string str = "1";
string r1 = interner.FindOrCreate("1", _ => str);
string r2 = interner.FindOrCreate("1", _ => null); // Should always be found
Assert.Equal(r1, r2); // 1: Objects should be equal
Assert.Same(r1, r2); // 2: Objects should be same / intern'ed
// Round-trip through Serializer
string r3 = (string)this.environment.SerializationManager.RoundTripSerializationForTesting(r1);
Assert.Equal(r1, r3); // 3: Should be equal
Assert.Equal(r2, r3); // 4: Should be equal
}
public void ID_Interning_string_equals()
{
Interner <string, string> interner = new Interner <string, string>();
const string str = "1";
string r1 = interner.FindOrCreate("1", () => str);
string r2 = interner.FindOrCreate("1", () => null); // Should always be found
Assert.AreEqual(r1, r2, "1: Objects should be equal");
Assert.AreSame(r1, r2, "2: Objects should be same / intern'ed");
// Round-trip through Serializer
string r3 = (string)SerializationManager.RoundTripSerializationForTesting(r1);
Assert.AreEqual(r1, r3, "3: Should be equal");
Assert.AreEqual(r2, r3, "4: Should be equal");
}
public void ID_Interning_string_equals()
{
Interner<string, string> interner = new Interner<string, string>();
const string str = "1";
string r1 = interner.FindOrCreate("1", () => str);
string r2 = interner.FindOrCreate("1", () => null); // Should always be found
Assert.AreEqual(r1, r2, "1: Objects should be equal");
Assert.AreSame(r1, r2, "2: Objects should be same / intern'ed");
// Round-trip through Serializer
string r3 = (string) SerializationManager.RoundTripSerializationForTesting(r1);
Assert.AreEqual(r1, r3, "3: Should be equal");
Assert.AreEqual(r2, r3, "4: Should be equal");
}
// Allocating methods
/**
* Allocates a new local name object. In C++, the refcount must be set up in such a way that
* calling <code>releaseLocal</code> on the return value balances the refcount set by this method.
*/
public static String newLocalNameFromBuffer(char[] buf, int offset, int length, Interner interner)
{
return new String(buf, offset, length);
}
/**
* Clones the attribute using an interner. Returns <code>this</code> in Java
* and for non-dynamic instances in C++.
*
* @param interner
* an interner
* @return a clone
*/
public AttributeName cloneAttributeName(Interner interner)
{
return this;
}
/**
* Returns an attribute name by buffer.
*
* <p>
* C++ ownership: The return value is either released by the caller if the
* attribute is a duplicate or the ownership is transferred to
* HtmlAttributes and released upon clearing or destroying that object.
*
* @param buf
* the buffer
* @param offset
* ignored
* @param length
* length of data
* @param checkNcName
* whether to check ncnameness
* @return an <code>AttributeName</code> corresponding to the argument data
*/
public static AttributeName nameByBuffer( char[] buf, int offset,
int length
// [NOCPP[
, bool checkNcName
// ]NOCPP]
, Interner interner)
{
// XXX deal with offset
int hash = AttributeName.bufToHash(buf, length);
int index = Array.BinarySearch(AttributeName.ATTRIBUTE_HASHES, hash);
if (index < 0) {
return AttributeName.createAttributeName(
Portability.newLocalNameFromBuffer(buf, offset, length,
interner)
// [NOCPP[
, checkNcName
// ]NOCPP]
);
} else {
AttributeName attributeName = AttributeName.ATTRIBUTE_NAMES[index];
String name = attributeName.getLocal(AttributeName.HTML);
if (!Portability.localEqualsBuffer(name, buf, offset, length)) {
return AttributeName.createAttributeName(
Portability.newLocalNameFromBuffer(buf, offset, length,
interner)
// [NOCPP[
, checkNcName
// ]NOCPP]
);
}
return attributeName;
}
}
// ]NOCPP]
public static ElementName elementNameByBuffer(char[] buf, int offset, int length, Interner interner)
{
int hash = ElementName.bufToHash(buf, length);
int index = Array.BinarySearch(ElementName.ELEMENT_HASHES, hash);
if (index < 0) {
return new ElementName(Portability.newLocalNameFromBuffer(buf, offset, length, interner));
} else {
ElementName elementName = ElementName.ELEMENT_NAMES[index];
string name = elementName.name;
if (!Portability.localEqualsBuffer(name, buf, offset, length)) {
return new ElementName(Portability.newLocalNameFromBuffer(buf,
offset, length, interner));
}
return elementName;
}
}
public ElementName cloneElementName(Interner interner)
{
return this;
}
public static String newLocalFromLocal(String local, Interner interner)
{
return local;
}
public CancellationSourcesExtension()
{
_cancellationTokens = new Interner<Guid, GrainCancellationToken>(
_defaultInternerCollectionSize,
_cleanupFrequency);
}
public void ID_Intern_derived_class()
{
Interner<int, A> interner = new Interner<int, A>();
var obj1 = new A();
var obj2 = new B();
var obj3 = new B();
var r1 = interner.InternAndUpdateWithMoreDerived(1, obj1);
Assert.AreEqual(obj1, r1, "Objects should be equal");
Assert.AreSame(obj1, r1, "Objects should be same / intern'ed");
var r2 = interner.InternAndUpdateWithMoreDerived(2, obj2);
Assert.AreEqual(obj2, r2, "Objects should be equal");
Assert.AreSame(obj2, r2, "Objects should be same / intern'ed");
// Interning should not replace instances of same class
var r3 = interner.InternAndUpdateWithMoreDerived(2, obj3);
Assert.AreSame(obj2, r3, "Interning should return previous object");
Assert.AreNotSame(obj3, r3, "Interning should not replace previous object of same class");
// Interning should return instances of most derived class
var r4 = interner.InternAndUpdateWithMoreDerived(1, obj2);
Assert.AreSame(obj2, r4, "Interning should return most derived object");
Assert.AreNotSame(obj1, r4, "Interning should replace cached instances of less derived object");
// Interning should not return instances of less derived class
var r5 = interner.InternAndUpdateWithMoreDerived(2, obj1);
Assert.AreNotSame(obj1, r5, "Interning should not return less derived object");
Assert.AreSame(obj2, r5, "Interning should return previously cached instances of more derived object");
}
public void ID_Intern_FindOrCreate_derived_class()
{
Interner<int, A> interner = new Interner<int, A>();
var obj1 = new A();
var obj2 = new B();
var obj3 = new B();
var r1 = interner.FindOrCreate(1, () => obj1);
Assert.AreEqual(obj1, r1, "Objects should be equal");
Assert.AreSame(obj1, r1, "Objects should be same / intern'ed");
var r2 = interner.FindOrCreate(2, () => obj2);
Assert.AreEqual(obj2, r2, "Objects should be equal");
Assert.AreSame(obj2, r2, "Objects should be same / intern'ed");
// FindOrCreate should not replace instances of same class
var r3 = interner.FindOrCreate(2, () => obj3);
Assert.AreSame(obj2, r3, "FindOrCreate should return previous object");
Assert.AreNotSame(obj3, r3, "FindOrCreate should not replace previous object of same class");
// FindOrCreate should not replace cached instances with instances of most derived class
var r4 = interner.FindOrCreate(1, () => obj2);
Assert.AreSame(obj1, r4, "FindOrCreate return previously cached object");
Assert.AreNotSame(obj2, r4, "FindOrCreate should not replace previously cached object");
// FindOrCreate should not replace cached instances with instances of less derived class
var r5 = interner.FindOrCreate(2, () => obj1);
Assert.AreNotSame(obj1, r5, "FindOrCreate should not replace previously cached object");
Assert.AreSame(obj2, r5, "FindOrCreate return previously cached object");
}
