public void BlobString_ToString_OutputIsIdentical(string input)
{
var blobString = new BlobString(input);
Debug.Log($"input - {input}, managed int string output - {blobString}");
Assert.AreEqual(input, blobString.ToString());
blobString.Dispose();
}
void HandleMonitorCallbacks(byte *bufferPtr, int addressLength, OscParser parser)
{
// handle monitor callbacks
var monitorAddressStr = new BlobString(bufferPtr, addressLength);
foreach (var callback in m_MonitorCallbacks)
{
callback(monitorAddressStr, parser.MessageValues);
}
}
protected override string PackageCommand(string commandName, params string[] args)
{
BlobString[] cmd = new BlobString[args.Length + 1];
cmd[0] = new BlobString(commandName);
for (int i = 0; i < args.Length; i++)
{
cmd[i + 1] = new BlobString(args[i]);
}
return(ArrayContainer.Package(cmd));
}
void Monitor(BlobString address, OscMessageValues values)
{
if (m_UseAlt)
{
m_ToQueueAlt.Add(MessageToString(address.ToString(), values));
}
else
{
m_ToQueue.Add(MessageToString(address.ToString(), values));
}
m_NeedsRepaint = true;
}
public void BlobString_GetHashCode_OutputSameAcrossInstances(string input)
{
var blobString1 = new BlobString(input);
var blobString2 = new BlobString(input);
var hashCode1 = blobString1.GetHashCode();
var hashCode2 = blobString2.GetHashCode();
blobString1.Dispose();
blobString2.Dispose();
Assert.AreEqual(hashCode1, hashCode2);
}
public void DictionaryTryGetValue_BlobString()
{
var blobStrings = new BlobString[m_Strings.Length];
for (int i = 0; i < m_Strings.Length; i++)
{
blobStrings[i] = new BlobString(m_Strings[i]);
}
var strDict = new Dictionary <string, int>(m_Strings.Length);
for (var i = 0; i < m_Strings.Length; i++)
{
strDict.Add(m_Strings[i], i);
}
var intStrDict = new Dictionary <BlobString, int>(blobStrings.Length);
for (var i = 0; i < blobStrings.Length; i++)
{
intStrDict.Add(blobStrings[i], i);
}
foreach (var blobString in blobStrings)
{
intStrDict.TryGetValue(blobString, out var index);
}
k_Stopwatch.Restart();
foreach (var str in m_Strings)
{
strDict.TryGetValue(str, out var index);
}
k_Stopwatch.Stop();
var strTicks = k_Stopwatch.ElapsedTicks;
k_Stopwatch.Restart();
foreach (var blobString in blobStrings)
{
intStrDict.TryGetValue(blobString, out var index);
}
k_Stopwatch.Stop();
var intStrTicks = k_Stopwatch.ElapsedTicks;
WriteLog($"Dictionary.TryGetValue, str {strTicks}, blobString {intStrTicks}");
foreach (var t in blobStrings)
{
t.Dispose();
}
}
public void Execute()
{
while (EffectCommandEnumerator.MoveNext())
{
string n1 = "";
string n2 = "";
if (EntityNames.Exists(EffectCommandEnumerator.Current.Emitter))
{
ref BlobString e1 = ref EntityNames[EffectCommandEnumerator.Current.Emitter].Value.Value.str;
n1 = e1.ToString();
}
if (EntityNames.Exists(EffectCommandEnumerator.Current.Target))
{
ref BlobString e2 = ref EntityNames[EffectCommandEnumerator.Current.Target].Value.Value.str;
n2 = e2.ToString();
}
public void BlobString_Equals()
{
var searchForIndex = StringCount / 4;
var searchString = m_Strings[searchForIndex];
var searchBlobString = new BlobString(searchString);
var blobStrings = new BlobString[m_Strings.Length];
for (int i = 0; i < m_Strings.Length; i++)
{
blobStrings[i] = new BlobString(m_Strings[i]);
}
bool eql;
// force the jit to compile the equals methods
foreach (var str in m_Strings)
{
eql = searchString.Equals(str);
}
foreach (var blobString in blobStrings)
{
eql = searchBlobString.Equals(blobString);
}
k_Stopwatch.Restart();
foreach (var str in m_Strings)
{
eql = searchString.Equals(str);
}
k_Stopwatch.Stop();
var strTicks = k_Stopwatch.ElapsedTicks;
k_Stopwatch.Restart();
foreach (var blobString in blobStrings)
{
eql = searchBlobString.Equals(blobString);
}
k_Stopwatch.Stop();
var intStrTicks = k_Stopwatch.ElapsedTicks;
WriteLog($"Equals(), str {strTicks}, blobString {intStrTicks}");
foreach (var t in blobStrings)
{
t.Dispose();
}
}
public void WriteBlobString(string value)
{
BlobString.Encoding = Encoding.ASCII;
var blobStr = new BlobString(value, Allocator.Temp);
m_Writer.Write(blobStr);
blobStr.Dispose();
var asciiByteCount = Encoding.ASCII.GetByteCount(value);
var alignedByteCount = (asciiByteCount + 3) & ~3;
var expected = alignedByteCount == asciiByteCount ? asciiByteCount + 4 : alignedByteCount;
Assert.AreEqual(expected, m_Writer.Length);
var convertedBack = Encoding.ASCII.GetString(m_Writer.Buffer, m_WriterLengthBefore, asciiByteCount);
Assert.AreEqual(value, convertedBack);
}
/// <summary>Write an ASCII string element. The string MUST be ASCII-encoded!</summary>
public void Write(BlobString data)
{
var strLength = data.Length;
System.Buffer.MemoryCopy(data.Handle.Pointer, m_BufferPtr + m_Length, strLength, strLength);
m_Length += strLength;
var alignedLength = (data.Length + 3) & ~3;
if (alignedLength == data.Length)
{
alignedLength += 4;
}
for (int i = data.Length; i < alignedLength; i++)
{
Buffer[m_Length++] = 0;
}
}
void Monitor(BlobString address, OscMessageValues values)
{
m_Dirty = true;
if (m_ReplaceLineIndex == k_LastIndex)
{
for (int i = 0; i < k_LastIndex; i++)
{
m_ReceivedAsString[i] = m_ReceivedAsString[i + 1];
}
}
m_ReceivedAsString[m_ReplaceLineIndex] = Utils.MonitorMessageToString(address, values);
if (m_ReplaceLineIndex < k_LastIndex)
{
m_ReplaceLineIndex++;
}
}
internal unsafe node_Accessor(long CellID, ActionOnCellNotFound action)
{
int tmp;
CellPtr = Global.LocalStorage.GetLockedUnsafeCellLocation(CellID, out tmp, out CellEntryIndex);
if (CellPtr == null)
{
if (action == ActionOnCellNotFound.ThrowException)
{
throw new CellNotFoundException("Cell with ID=" + CellID + " not found!");
}
else if (action == ActionOnCellNotFound.CreateNew)
{
int size;
byte[] defaultContent = construct(CellID);
CellPtr = Global.LocalStorage.AddOrUse(CellID, out size, out CellEntryIndex, defaultContent, (ushort)CellType.node);
}
else
{
this.CellID = -1;
return;
}
}
name_Accessor_Field = new BlobString(null,
(ptr, ptr_offset, delta) =>
{
int substructure_offset = (int)(ptr - this.CellPtr);
this.ResizeFunction(this.CellPtr, ptr_offset + substructure_offset, delta);
return(this.CellPtr + substructure_offset);
});
friends_Accessor_Field = new longList(null,
(ptr, ptr_offset, delta) =>
{
int substructure_offset = (int)(ptr - this.CellPtr);
this.ResizeFunction(this.CellPtr, ptr_offset + substructure_offset, delta);
return(this.CellPtr + substructure_offset);
});
this.CellID = CellID;
}
public void Add(string address, OscActionPair callbacks)
{
if (!SourceToBlob.TryGetValue(address, out var blobStr))
{
blobStr = new BlobString(address);
HandleToValue[blobStr.Handle] = callbacks;
SourceToBlob.Add(address, blobStr);
}
else
{
if (HandleToValue.ContainsKey(blobStr.Handle))
{
HandleToValue[blobStr.Handle] += callbacks;
}
else
{
HandleToValue[blobStr.Handle] = callbacks;
}
}
}
public void ManagedBlobString_GetHashCode()
{
var blobStrings = new BlobString[m_Strings.Length];
for (int i = 0; i < m_Strings.Length; i++)
{
blobStrings[i] = new BlobString(m_Strings[i]);
}
// force jit to compile hashcode method
foreach (var blobString in blobStrings)
{
var hc = blobString.GetHashCode();
}
int hashCode;
k_Stopwatch.Restart();
foreach (var str in m_Strings)
{
hashCode = str.GetHashCode();
}
k_Stopwatch.Stop();
var strTicks = k_Stopwatch.ElapsedTicks;
k_Stopwatch.Restart();
foreach (var blobString in blobStrings)
{
hashCode = blobString.GetHashCode();
}
k_Stopwatch.Stop();
var intStrTicks = k_Stopwatch.ElapsedTicks;
WriteLog($"GetHashCode(), str {strTicks}, blobString {intStrTicks}");
foreach (var t in blobStrings)
{
t.Dispose();
}
}
internal unsafe node_Accessor(byte *_CellPtr)
{
CellPtr = _CellPtr;
name_Accessor_Field = new BlobString(null,
(ptr, ptr_offset, delta) =>
{
int substructure_offset = (int)(ptr - this.CellPtr);
this.ResizeFunction(this.CellPtr, ptr_offset + substructure_offset, delta);
return(this.CellPtr + substructure_offset);
});
friends_Accessor_Field = new longList(null,
(ptr, ptr_offset, delta) =>
{
int substructure_offset = (int)(ptr - this.CellPtr);
this.ResizeFunction(this.CellPtr, ptr_offset + substructure_offset, delta);
return(this.CellPtr + substructure_offset);
});
this.CellEntryIndex = -1;
}
internal unsafe NameRequest_Accessor(byte *_CellPtr, ResizeFunctionPrototype func)
{
CellPtr = _CellPtr;
ResizeFunction = func;
name_Accessor_Field = new BlobString(null,
(ptr, ptr_offset, delta) =>
{
int substructure_offset = (int)(ptr - this.CellPtr);
this.CellPtr = this.ResizeFunction(this.CellPtr, ptr_offset + substructure_offset, delta);
return(this.CellPtr + substructure_offset);
});
neighbours_Accessor_Field = new longList(null,
(ptr, ptr_offset, delta) =>
{
int substructure_offset = (int)(ptr - this.CellPtr);
this.CellPtr = this.ResizeFunction(this.CellPtr, ptr_offset + substructure_offset, delta);
return(this.CellPtr + substructure_offset);
});
}
public unsafe void BlobStringLookup_TryGetValueFromBytes()
{
var blobStrings = new BlobString[m_Strings.Length];
var bytes = new byte[m_Strings.Length][];
for (int i = 0; i < m_Strings.Length; i++)
{
var str = m_Strings[i];
blobStrings[i] = new BlobString(str);
var b = Encoding.ASCII.GetBytes(str);
bytes[i] = b;
}
var lookup = new BlobStringDictionary <int>();
for (int i = 0; i < blobStrings.Length; i++)
lookup.Add(blobStrings[i], i);
// force JIT compilation of the relevant method
fixed(byte *dummyPtr = bytes[0])
{
lookup.TryGetValueFromBytes(dummyPtr, bytes[0].Length, out var value);
}
k_Stopwatch.Reset();
foreach (var byteStr in bytes)
{
fixed(byte *byteStrPtr = byteStr)
{
k_Stopwatch.Start();
lookup.TryGetValueFromBytes(byteStrPtr, byteStr.Length, out var value);
k_Stopwatch.Stop();
}
}
WriteLog($"TryGetValueFromBytes(byte* ) ticks: {k_Stopwatch.ElapsedTicks}");
foreach (var t in blobStrings)
t.Dispose(); }
public node_Accessor(long cellId, byte[] buffer)
{
this.CellID = cellId;
handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
this.CellPtr = (byte *)handle.AddrOfPinnedObject().ToPointer();
name_Accessor_Field = new BlobString(null,
(ptr, ptr_offset, delta) =>
{
int substructure_offset = (int)(ptr - this.CellPtr);
this.ResizeFunction(this.CellPtr, ptr_offset + substructure_offset, delta);
return(this.CellPtr + substructure_offset);
});
friends_Accessor_Field = new longList(null,
(ptr, ptr_offset, delta) =>
{
int substructure_offset = (int)(ptr - this.CellPtr);
this.ResizeFunction(this.CellPtr, ptr_offset + substructure_offset, delta);
return(this.CellPtr + substructure_offset);
});
this.CellEntryIndex = -1;
}
public static string MonitorMessageToString(BlobString address, OscMessageValues values)
{
k_Builder.Clear();
k_Builder.Append(address.ToString());
const string divider = " ,";
k_Builder.Append(divider);
values.ForEachElement((i, type) => { k_Builder.Append((char)type); });
k_Builder.Append(" ");
var lastIndex = values.ElementCount - 1;
values.ForEachElement((i, type) =>
{
var elementText = values.ReadStringElement(i);
k_Builder.Append(elementText);
if (i != lastIndex)
{
k_Builder.Append(' ');
}
});
return(k_Builder.ToString());
}
void Serve()
{
#if OSCCORE_PROFILING && UNITY_EDITOR
Profiler.BeginThreadProfiling("OscCore", "Server");
#endif
var buffer = m_ReadBuffer;
var bufferPtr = Parser.BufferPtr;
var bufferLongPtr = Parser.BufferLongPtr;
var parser = Parser;
var addressToMethod = AddressSpace.AddressToMethod;
var socket = m_Socket;
while (!m_Disposed)
{
try
{
// it's probably better to let Receive() block the thread than test socket.Available > 0 constantly
int receivedByteCount = socket.Receive(buffer, 0, buffer.Length, SocketFlags.None);
if (receivedByteCount == 0)
{
continue;
}
Profiler.BeginSample("Receive OSC");
// determine if the message is a bundle or not
if (*bufferLongPtr != Constant.BundlePrefixLong)
{
// address length here doesn't include the null terminator and alignment padding.
// this is so we can look up the address by only its content bytes.
var addressLength = parser.FindAddressLength();
if (addressLength < 0)
{
// address didn't start with '/'
Profiler.EndSample();
continue;
}
var alignedAddressLength = (addressLength + 3) & ~3;
// if the null terminator after the string comes at the beginning of a 4-byte block,
// we need to add 4 bytes of padding
if (alignedAddressLength == addressLength)
{
alignedAddressLength += 4;
}
var tagCount = parser.ParseTags(buffer, alignedAddressLength);
if (tagCount <= 0)
{
Profiler.EndSample();
continue;
}
var offset = alignedAddressLength + (tagCount + 4) & ~3;
parser.FindOffsets(offset);
// see if we have a method registered for this address
if (addressToMethod.TryGetValueFromBytes(bufferPtr, addressLength, out var methodPair))
{
// call the value read method associated with this OSC address
methodPair.ValueRead(parser.MessageValues);
// if there's a main thread method, queue it
if (methodPair.MainThreadQueued != null)
{
if (m_MainThreadCount >= m_MainThreadQueue.Length)
{
Array.Resize(ref m_MainThreadQueue, m_MainThreadQueue.Length * 2);
}
m_MainThreadQueue[m_MainThreadCount++] = methodPair.MainThreadQueued;
}
}
else if (AddressSpace.PatternCount > 0)
{
TryMatchPatterns(parser, bufferPtr, addressLength);
}
Profiler.EndSample();
if (m_MonitorCallbacks.Count == 0)
{
continue;
}
// handle monitor callbacks
var monitorAddressStr = new BlobString(bufferPtr, addressLength);
foreach (var callback in m_MonitorCallbacks)
{
callback(monitorAddressStr, parser.MessageValues);
}
continue;
}
// the message is a bundle, so we need to recursively scan the bundle elements
int MessageOffset = 0;
bool recurse;
// the outer do-while loop runs once for every #bundle encountered
do
{
// Timestamp isn't used yet, but it will be eventually
// var time = parser.MessageValues.ReadTimestampIndex(MessageOffset + 8);
// '#bundle ' + timestamp = 16 bytes
MessageOffset += 16;
recurse = false;
// the inner while loop runs once per bundle element
while (MessageOffset < receivedByteCount && !recurse)
{
var messageSize = (int)parser.MessageValues.ReadUIntIndex(MessageOffset);
var contentIndex = MessageOffset + 4;
if (parser.IsBundleTagAtIndex(contentIndex))
{
// this bundle element's contents are a bundle, break out to the outer loop to scan it
MessageOffset = contentIndex;
recurse = true;
continue;
}
var bundleAddressLength = parser.FindAddressLength(contentIndex);
if (bundleAddressLength <= 0)
{
// if an error occured parsing the address, skip this message entirely
MessageOffset += messageSize + 4;
continue;
}
var bundleTagCount = parser.ParseTags(buffer, contentIndex + bundleAddressLength);
if (bundleTagCount <= 0)
{
MessageOffset += messageSize + 4;
continue;
}
// skip the ',' and align to 4 bytes
var bundleOffset = (contentIndex + bundleAddressLength + bundleTagCount + 4) & ~3;
parser.FindOffsets(bundleOffset);
if (addressToMethod.TryGetValueFromBytes(bufferPtr + contentIndex, bundleAddressLength,
out var bundleMethodPair))
{
// call the value read method associated with this OSC address
bundleMethodPair.ValueRead(parser.MessageValues);
// if there's a main thread method, queue it
if (bundleMethodPair.MainThreadQueued != null)
{
if (m_MainThreadCount >= m_MainThreadQueue.Length)
{
Array.Resize(ref m_MainThreadQueue, m_MainThreadQueue.Length * 2);
}
m_MainThreadQueue[m_MainThreadCount++] = bundleMethodPair.MainThreadQueued;
}
}
// if we have no handler for this exact address, we may have a pattern that matches it
else if (AddressSpace.PatternCount > 0)
{
TryMatchPatterns(parser, bufferPtr, bundleAddressLength);
}
MessageOffset += messageSize + 4;
if (m_MonitorCallbacks.Count == 0)
{
continue;
}
var bundleMemberAddressStr = new BlobString(bufferPtr + contentIndex, bundleAddressLength);
foreach (var callback in m_MonitorCallbacks)
{
callback(bundleMemberAddressStr, parser.MessageValues);
}
}
}
// restart the outer while loop every time a bundle within a bundle is detected
while (recurse);
Profiler.EndSample();
}
// a read timeout can result in a socket exception, should just be ok to ignore
catch (SocketException) { }
catch (ThreadAbortException) {}
catch (Exception e)
{
if (!m_Disposed)
{
Debug.LogException(e);
}
break;
}
}
Profiler.EndThreadProfiling();
}
