Event Pipe File V3 (#16107)

* write missing information to the event pipe file (pointer size to make it work fo x86)

* define where the events start, not only where they end

* include process Id in the event pipe file, bump the version so old consumers get clear error message

* write the missing EndObject tag to close the header

* include expected CPU sampling rate in the event pipe header file

* include keywords in V3 of EventPipe metadata, fixes #11934

* remove forward references

* entry object comes after the header and ends after it's data, before the event block objects

* introduce event block

* fix the GC contracts

* generate metadata ids

* end the file with null reference tag

* getting it work

* 4 byte alignment of serialized event data

* Revert "include keywords in V3 of EventPipe metadata, fixes #11934"

This reverts commit 98ef2f588e271f928fd051e96da526dc1e0f017c.

* remove event Id and event version from metadata buffer (it was duplicated with native code)

* increase the block size to be the same as buffer size

* Write the last event block to the file after disabling the event pipe, right after last events

* include the sife in itself

* the native part was supposed to not duplicate the event id and version, not manged

* ensure 4 byte alignment

* build metadata when it's not provided, so payload is never empty (no need to serialize length)

* this todo is no longer valid

* don't align everything, just the content of event block as suggested by @vancem

* improvements after code review

* update TraceEvent dependency, make the test verify new feature

* InterlockedIncrement(Int32) is not available for non-Windows OSes

* code improvements after Skype code review from @jorive

1 files changed, 58 insertions, 2 deletions

diff --git a/src/vm/eventpipeevent.cpp b/src/vm/eventpipeevent.cpp
index 1b2d4ebe40..3f7755149b 100644
--- a/src/vm/eventpipeevent.cpp
+++ b/src/vm/eventpipeevent.cpp
@@ -33,8 +33,9 @@ EventPipeEvent::EventPipeEvent(EventPipeProvider &provider, INT64 keywords, unsi
     }
     else
     {
-        m_pMetadata = NULL;
-        m_metadataLength = 0;
+        // if metadata is not provided, we have to build the minimum version. It's required by the serialization contract
+        m_pMetadata = BuildMinimumMetadata();
+        m_metadataLength = GetMinimumMetadataLength();
     }
 }
 
@@ -55,6 +56,61 @@ EventPipeEvent::~EventPipeEvent()
     }
 }
 
+unsigned int EventPipeEvent::GetMinimumMetadataLength()
+{
+    LIMITED_METHOD_CONTRACT;
+    
+    unsigned int minimumMetadataLength =
+        sizeof(m_eventID) +
+        (SString::Empty().GetCount() + 1) * sizeof(WCHAR) + // size of empty unicode string
+        sizeof(m_keywords) +
+        sizeof(m_eventVersion) +
+        sizeof(m_level) +
+        sizeof(unsigned int); // parameter count
+
+    return minimumMetadataLength;
+}
+
+BYTE *EventPipeEvent::BuildMinimumMetadata()
+{
+    CONTRACTL
+    {
+        THROWS;
+        GC_NOTRIGGER;
+        MODE_ANY;
+    }
+    CONTRACTL_END;
+
+    unsigned int minmumMetadataLength = GetMinimumMetadataLength();
+
+    BYTE *minmumMetadata = new BYTE[minmumMetadataLength];
+    BYTE *currentPtr = minmumMetadata;
+
+    // the order of fields is defined in coreclr\src\mscorlib\shared\System\Diagnostics\Tracing\EventSource.cs DefineEventPipeEvents method
+    memcpy(currentPtr, &m_eventID, sizeof(m_eventID));
+    currentPtr += sizeof(m_eventID);
+
+    SString eventName = SString::Empty();
+    unsigned int eventNameSize = (eventName.GetCount() + 1) * sizeof(WCHAR);
+    memcpy(currentPtr, (BYTE*)eventName.GetUnicode(), eventNameSize);
+    currentPtr += eventNameSize;
+
+    memcpy(currentPtr, &m_keywords, sizeof(m_keywords));
+    currentPtr += sizeof(m_keywords);
+
+    memcpy(currentPtr, &m_eventVersion, sizeof(m_eventVersion));
+    currentPtr += sizeof(m_eventVersion);
+
+    memcpy(currentPtr, &m_level, sizeof(m_level));
+    currentPtr += sizeof(m_level);
+
+    unsigned int noParameters = 0;
+    memcpy(currentPtr, &noParameters, sizeof(noParameters));
+    currentPtr += sizeof(noParameters);
+
+    return minmumMetadata;
+}
+
 EventPipeProvider* EventPipeEvent::GetProvider() const
 {
     LIMITED_METHOD_CONTRACT;