Add a test for testing the runtime function counters functionality

Author: swiftix

test/stdlib/test_runtime_function_counters.swift

@@ -0,0 +1,256 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift %s -o %t/test_runtime_function_counters
+// RUN: %target-run %t/test_runtime_function_counters 2>&1 | %FileCheck %s
+// REQUIRES: asserts
+// REQUIRES: executable_test
+
+/// Test functionality related to the runtime function counters.
+
+class C {
+    var next: C? = nil
+    func test(_ c: C) {
+    }
+}
+
+struct MyStruct {
+  var ref1: AnyObject? = C()
+  var ref2: AnyObject = C()
+  var str: String = ""
+}
+
+public final class List<T> {
+  var value: T
+  var next: List<T>?
+
+  init(_ value: T) {
+    self.value = value
+    self.next = nil
+  }
+
+  init(_ value: T, _ tail: List<T>) {
+    self.value = value
+    self.next = tail
+  }
+}
+
+public func length<T>(_ l: List<T>) -> Int {
+  var ll: List<T>? = l
+  var len = 0
+  while ll != nil {
+    len = len + 1
+    ll = ll?.next
+  }
+  return len
+}
+
+/// CHECK-LABEL: TEST: Collect references inside objects
+/// Constant strings do not have an owner, thus no references.
+/// CHECK: Constant string: []
+/// An array has one reference
+/// CHECK: Array<Int>: [{{[0-9a-fA-Fx]+}}]
+/// MyStruct has two references
+/// CHECK: MyStruct: [{{[0-9a-fA-Fx]+}}, {{[0-9a-fA-Fx]+}}]
+/// Dictionary has once reference
+/// CHECK: Dictionary<Int, Int>: [{{[0-9a-fA-Fx]+}}]
+/// Set has once reference
+/// CHECK: Set<Int>: [{{[0-9a-fA-Fx]+}}]
+/// Test collection of references inside different types of objects.
+@inline(never)
+func testCollectReferencesInsideObject() {
+  print("TEST: Collect references inside objects")
+  let s = "MyString"
+  let aint = [1,2,3,4]
+  let dint = [1:1, 2:2]
+  let sint: Set<Int> = [1,2,3,4]
+
+  print("Constant string: \(_collectReferencesInsideObject(s))")
+  print("Array<Int>: \(_collectReferencesInsideObject(aint))")
+  print("MyStruct: \(_collectReferencesInsideObject(MyStruct()))")
+  print("Dictionary<Int, Int>: \(_collectReferencesInsideObject(dint))")
+  print("Set<Int>: \(_collectReferencesInsideObject(sint))")
+
+  var mystring = "MyString"
+  mystring.append("End")
+  testString(mystring)
+  testDict(dint)
+  testObjectCycle()
+}
+
+
+/// CHECK-LABEL: TEST: APIs from _RuntimeFunctionCounters
+/// CHECK: Number of runtime function pointers:
+/// Test some APIs from _RuntimeFunctionCounters
+func testRuntimeCounters() {
+  print("TEST: APIs from _RuntimeFunctionCounters")
+  let numRuntimeFunctionPointer =
+    _RuntimeFunctionCounters.getNumRuntimeFunctionCounters()
+
+  print("Number of runtime function pointers: \(numRuntimeFunctionPointer)")
+
+  let names = _RuntimeFunctionCounters.getRuntimeFunctionNames()
+  let offsets = _RuntimeFunctionCounters.getRuntimeFunctionCountersOffsets()
+
+  for i in 0..<numRuntimeFunctionPointer {
+    print("Runtime function \(i) : \(names[i]) at offset: \(offsets[i])")
+  }
+
+  var d: [Int : Int] = [:]
+  let globalCounters1 = _GlobalRuntimeFunctionCountersState()
+
+  for i in 0..<50 {
+    let k = i
+    let v = i*i
+    d[k] = v
+  }
+
+  let globalCounters2 = _GlobalRuntimeFunctionCountersState()
+
+  globalCounters1.dumpDiff(globalCounters2)
+}
+
+/// Test finding references inside a String object.
+@inline(never)
+func testString(_ s: String) {
+  print("TEST: Collect references for strings")
+  let refs = _collectReferencesInsideObject(s)
+  print("References are: \(refs)")
+  let objectCounters1 = _ObjectRuntimeFunctionCountersState(refs[0])
+  let _ = [String](repeating: s, count: 4)
+  let objectCounters2 = _ObjectRuntimeFunctionCountersState(refs[0])
+  objectCounters1.dumpDiff(objectCounters2)
+}
+
+/// Test finding references inside a Dictionary object.
+@inline(never)
+func testDict(_ _dint: [Int : Int]) {
+  print("TEST: Collect references for dictionaries")
+  var dint = _dint
+  dint[3] = 3
+  let refs = _collectReferencesInsideObject(dint)
+  print("References are: \(refs)")
+  let objectCounters1 = _ObjectRuntimeFunctionCountersState(refs[0])
+  dint[222] = 222
+  dint[2222] = 2222
+  let objectCounters2 = _ObjectRuntimeFunctionCountersState(refs[0])
+  objectCounters1.dumpDiff(objectCounters2)
+}
+
+/// Test finding references inside an object graph with a cycle.
+/// It should not result in a stack overflow.
+@inline(never)
+func testObjectCycle() {
+  print("TEST: Collect references on object graph with cycles")
+  print("testObjectCycle")
+  let c1 = C()
+  let c2 = C()
+  c1.next = c1
+  c2.next = c1
+  let refs = _collectReferencesInsideObject(c1)
+  print("References are: \(refs)")
+  let objectCounters1 = _ObjectRuntimeFunctionCountersState(refs[0])
+  c1.next = nil
+  c2.next = nil
+  let objectCounters2 = _ObjectRuntimeFunctionCountersState(refs[0])
+  objectCounters1.dumpDiff(objectCounters2, skipUnchanged: true)
+}
+
+/// Test runtime function counters for a List object.
+@inline(never)
+func testLists() {
+  print("TEST: Runtime function counters for Lists")
+  print("testLists")
+  let globalCounters1 = _GlobalRuntimeFunctionCountersState()
+  var l: List<Int>? = List(1, List(2, List(3, List(4, List(5)))))
+  let refs = _collectReferencesInsideObject(l!)
+  let globalCounters11 = _GlobalRuntimeFunctionCountersState()
+  let _ = _collectReferencesInsideObject(l!)
+  let globalCounters111 = _GlobalRuntimeFunctionCountersState()
+
+  print("Global counters diff for 11")
+  globalCounters1.dumpDiff(globalCounters11, skipUnchanged: true)
+  print("Global counters diff for 111")
+  globalCounters1.dumpDiff(globalCounters111, skipUnchanged: true)
+
+  let len = length(l!)
+  let globalCounters2 = _GlobalRuntimeFunctionCountersState()
+  print("Length of the list is \(len)")
+  print("Global counters diff after constructing a list and computing its length")
+  globalCounters1.dumpDiff(globalCounters2, skipUnchanged: true)
+  let objectCounters1 = _ObjectRuntimeFunctionCountersState(refs[0])
+  l = nil
+  let objectCounters2 = _ObjectRuntimeFunctionCountersState(refs[0])
+  print("List head counters after list becomes unreferenced")
+  objectCounters1.dumpDiff(objectCounters2, skipUnchanged: true)
+}
+
+/// Test the _measureRuntimeFunctionCountersDiffs API.
+@inline(never)
+func testMeasureRuntimeFunctionCountersDiffs() {
+  print("TEST: Measure runtime function counters diff")
+  let l: List<Int>? = List(1, List(2, List(3, List(4, List(5)))))
+  let refs = _collectReferencesInsideObject(l!)
+  var len = 0
+  let (globalCounters, objectsCountersDiffs) =
+    _measureRuntimeFunctionCountersDiffs(objects: [refs[0]]) {
+    len = length(l!)
+  }
+  print("List length is: \(len)")
+  print("Global counters changes")
+  globalCounters.dump(skipUnchanged: true)
+  print("Objects counters changes")
+  for (i, objectCounters) in objectsCountersDiffs.enumerated() {
+    print("Object counters diff for \(refs[i])")
+    objectCounters.dump(skipUnchanged: true)
+  }
+}
+
+/// This is a handler that is invoked on each runtime functions counters update.
+@inline(never)
+func updatesHandler(object: UnsafeRawPointer, functionId: Int64) {
+  let savedMode = _RuntimeFunctionCounters.disableRuntimeFunctionCountersUpdates()
+  print("Start handler")
+  let functionName = _RuntimeFunctionCounters.runtimeFunctionNames[Int(functionId)]
+  print("Function \(functionName) was invoked on object \(object)")
+  print("End handler")
+  _RuntimeFunctionCounters.enableRuntimeFunctionCountersUpdates(mode: savedMode)
+}
+
+/// CHECK-LABEL: TEST: Provide runtime function counters update handler
+/// TEST: Start handler
+/// TEST: End handler
+/// Test that you can provide custom handlers for runtime functions counters
+/// updates.
+@inline(never)
+func testFunctionRuntimeCountersUpdateHandler() {
+  print("TEST: Provide runtime function counters update handler")
+  let l: List<Int>? = List(1, List(2, List(3, List(4, List(5)))))
+  let oldHandler =
+    _RuntimeFunctionCounters.setGlobalRuntimeFunctionCountersUpdateHandler(
+      handler: updatesHandler)
+  let len = length(l!)
+  _ = _RuntimeFunctionCounters.setGlobalRuntimeFunctionCountersUpdateHandler(
+    handler: oldHandler)
+  print("Restored old handler")
+  print(len)
+}
+
+/// Enable runtime function counters stats collection.
+_RuntimeFunctionCounters.enableRuntimeFunctionCountersUpdates()
+
+/// Test collection of references inside different types of objects.
+testCollectReferencesInsideObject()
+
+/// Test some APIs from _RuntimeFunctionCounters.
+testRuntimeCounters()
+
+/// Test dumping of counters for all objects.
+_RuntimeFunctionCounters.dumpObjectsRuntimeFunctionPointers()
+
+/// Test runtime function counters for a List object.
+testLists()
+
+/// Test the _measureRuntimeFunctionCountersDiffs API.
+testMeasureRuntimeFunctionCountersDiffs()
+
+/// Test that you can provide custom handlers for runtime functions counters updates.
+testFunctionRuntimeCountersUpdateHandler()