chore: add Swift example (#55)

Parca currently does not work great on handling Swift processes.

1. Most of the stacks are shown as "calculate", dropping the full
function names and arguments
<img width="2500" height="942" alt="parca"
src="https://github.com/user-attachments/assets/90a54c7d-06d8-4c12-b20d-d5f4c649d517"
/>
2. Demangling to Foundation calls is missing
<img width="1159" height="807" alt="demangle"
src="https://github.com/user-attachments/assets/047ebf40-fbf0-42ff-a5b5-2797e8dfd94c"
/>

The same workload when sampled via perf_events and piping demangling via
`swift-demangle` for comparison:


![perf-events-swift-demangle-parca-demo](https://github.com/user-attachments/assets/ce2a4a9a-0a97-4f49-ae6d-77b609cd7464)

Author: vsarunas

swift/Dockerfile

@@ -0,0 +1,10 @@
+FROM docker.io/swift:bookworm
+
+WORKDIR /app
+
+COPY . .
+
+ENV MODE=release
+RUN swift build -c ${MODE} && cp .build/${MODE}/ParcaDemo ./parca-demo
+
+ENTRYPOINT ["./parca-demo"]

swift/Makefile

@@ -0,0 +1,3 @@
+.PHONY: build
+build:
+	docker build -t parca-demo:swift .

swift/Package.resolved

@@ -0,0 +1,22 @@
+// swift-tools-version: 6.1
+// The swift-tools-version declares the minimum version of Swift required to build this package.
+
+import PackageDescription
+
+let package = Package(
+    name: "parca-demo",
+    dependencies: [
+        .package(url: "https://github.com/apple/swift-log", from: "1.6.4"),
+        .package(url: "https://github.com/apple/swift-argument-parser", from: "1.6.1")
+    ],
+    targets: [
+        .executableTarget(
+            name: "ParcaDemo",
+            dependencies: [
+                .product(name: "Logging", package: "swift-log"),
+                .product(name: "ArgumentParser", package: "swift-argument-parser"),
+            ],
+            path: "Sources"
+        )
+    ]
+)

swift/Package.swift

@@ -0,0 +1,43 @@
+import Foundation
+import Logging
+
+struct FibonacciResult {
+  let value: UInt64
+  let input: UInt64
+  let timestamp: Date
+
+  var json: String {
+    let dict = ["fibonacci": "\(value)", "input": "\(input)", "timestamp": "\(timestamp)"]
+    guard let data = try? JSONSerialization.data(withJSONObject: dict),
+      let string = String(data: data, encoding: .utf8)
+    else {
+      return "error"
+    }
+    return string
+  }
+}
+
+struct FibonacciCalculator {
+  private let logger: Logger
+
+  init(logger: Logger) {
+    self.logger = logger
+  }
+
+  @inline(never)
+  func calculate(_ n: UInt64) -> UInt64 {
+    switch n {
+    case 0:
+      fatalError("zero not allowed")
+    case 1, 2:
+      return 1
+    default:
+      return calculate(n - 1) + calculate(n - 2)
+    }
+  }
+
+  func calculateWithResult(_ n: UInt64) -> FibonacciResult {
+    let value = calculate(n)
+    return FibonacciResult(value: value, input: n, timestamp: Date())
+  }
+}

swift/Sources/Fibonacci.swift

@@ -0,0 +1,18 @@
+import Synchronization
+
+class MemoryManager {
+  private let buffers = Mutex<[[UInt8]]>([])
+
+  @inline(never)
+  func allocateChunk(size: Int) {
+    buffers.withLock { buffers in
+      buffers.append(Array(repeating: 0, count: size))
+    }
+  }
+
+  var totalMemory: Int {
+    buffers.withLock { buffers in
+      buffers.reduce(0) { $0 + $1.count }
+    }
+  }
+}

swift/Sources/Memory.swift

@@ -0,0 +1,56 @@
+import ArgumentParser
+import Foundation
+import Logging
+import Synchronization
+
+@main
+struct Repeat: AsyncParsableCommand {
+  static let logger = Logger(label: "dev.parca-demo.swift")
+
+  @Option(help: "Fibonacci number to calculate")
+  var fibNumber: UInt64 = 42
+
+  @Option(help: "Memory allocation size in KB")
+  var memSize: Int = 20
+
+  func run() async throws {
+    let calculator = FibonacciCalculator(logger: Self.logger)
+    let memoryManager = MemoryManager()
+
+    let cpu = Task.detached {
+      while true {
+        let result = calculator.calculateWithResult(self.fibNumber)
+        Self.logger.info("CPU result: \(result.json)")
+        try await Task.sleep(for: .seconds(1))
+      }
+    }
+
+    let mem = Task.detached {
+      while true {
+        Self.logger.info("Allocating memory...")
+        memoryManager.allocateChunk(size: self.memSize * 1024)
+        Self.logger.info("Total memory: \(memoryManager.totalMemory)")
+        try await Task.sleep(for: .seconds(1))
+      }
+    }
+
+    let foundation = Task.detached {
+      while true {
+        let date = Date()
+        let formatter = DateFormatter()
+        formatter.dateStyle = .full
+        let _ = formatter.string(from: date)
+
+        let uuid = UUID()
+        let _ = URL(string: "https://example.com/\(uuid.uuidString)")
+
+        Self.logger.info("Foundation operations completed")
+        try await Task.sleep(for: .seconds(2))
+      }
+    }
+
+    _ = await cpu.result
+    _ = await mem.result
+    _ = await foundation.result
+  }
+}

swift/Sources/ParcaDemo.swift

@@ -0,0 +1,24 @@
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  labels:
+    app.kubernetes.io/name: demo-swift
+  name: swift 
+  namespace: parca
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app.kubernetes.io/name: demo-swift
+  template:
+    metadata:
+      labels:
+        app.kubernetes.io/name: demo-swift
+    spec:
+      containers:
+      - image: parca-demo:swift
+        name: rust
+        resources:
+          limits:
+            cpu: '100m'
+            memory: '256Mi'