[benchmark] Fix swiftpm based benchmark build on Linux.

benchmark/Package.swift

@@ -3,13 +3,19 @@
 import PackageDescription
 import Foundation
 
+var unsupportedTests: Set<String> = ["ObjectiveCNoBridgingStubs"]
+#if !os(macOS) && !os(iOS) && !os(watchOS) && !os(tvOS)
+unsupportedTests.insert("ObjectiveCBridging")
+unsupportedTests.insert("ObjectiveCBridgingStubs")
+#endif
+
 // This is a stop gap hack so we can edit benchmarks in Xcode.
 let singleSourceLibraries: [String] = {
   let f = FileManager.`default`
   let dirURL = URL(fileURLWithPath: "single-source").absoluteURL
   let fileURLs = try! f.contentsOfDirectory(at: dirURL,
                                             includingPropertiesForKeys: nil)
-  return fileURLs.flatMap { (path: URL) -> String? in
+  return fileURLs.compactMap { (path: URL) -> String? in
     let c = path.lastPathComponent.split(separator: ".")
     // Too many components. Must be a gyb file.
     if c.count > 2 {
@@ -19,13 +25,15 @@ let singleSourceLibraries: [String] = {
       return nil
     }
 
+    let s = String(c[0])
+
     // We do not support this test.
-    if c[0] == "ObjectiveCNoBridgingStubs" {
+    if unsupportedTests.contains(s) {
       return nil
     }
 
-    assert(c[0] != "PrimsSplit")
-    return String(c[0])
+    assert(s != "PrimsSplit")
+    return s
   }
 }()
 
@@ -42,7 +50,9 @@ let multiSourceLibraries: [String] = {
 var products: [Product] = []
 products.append(.library(name: "TestsUtils", type: .static, targets: ["TestsUtils"]))
 products.append(.library(name: "DriverUtils", type: .static, targets: ["DriverUtils"]))
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
 products.append(.library(name: "ObjectiveCTests", type: .static, targets: ["ObjectiveCTests"]))
+#endif
 products.append(.executable(name: "SwiftBench", targets: ["SwiftBench"]))
 products.append(.library(name: "PrimsSplit", type: .static, targets: ["PrimsSplit"]))
 products += singleSourceLibraries.map { .library(name: $0, type: .static, targets: [$0]) }
@@ -56,26 +66,35 @@ targets.append(
     dependencies: [.target(name: "TestsUtils"), "LibProc"],
     path: "utils",
     sources: ["DriverUtils.swift", "ArgParse.swift"]))
+
+var swiftBenchDeps: [Target.Dependency] = [.target(name: "TestsUtils")]
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+swiftBenchDeps.append(.target(name: "ObjectiveCTests"))
+#endif
+swiftBenchDeps.append(.target(name: "DriverUtils"))
+swiftBenchDeps += singleSourceLibraries.map { .target(name: $0) }
+swiftBenchDeps += multiSourceLibraries.map { .target(name: $0) }
+
 targets.append(
     .target(name: "SwiftBench",
-    dependencies: [
-      .target(name: "TestsUtils"),
-      .target(name: "ObjectiveCTests"),
-      .target(name: "DriverUtils"),
-    ] + singleSourceLibraries.map { .target(name: $0) }
-    + multiSourceLibraries.map { .target(name: $0) },
+    dependencies: swiftBenchDeps,
     path: "utils",
     sources: ["main.swift"]))
+
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
 targets.append(
   .target(name: "ObjectiveCTests",
     path: "utils/ObjectiveCTests",
     publicHeadersPath: "."))
+#endif
+
+var singleSourceDeps: [Target.Dependency] = [.target(name: "TestsUtils")]
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
+singleSourceDeps.append(.target(name: "ObjectiveCTests"))
+#endif
 targets += singleSourceLibraries.map { x in
     return .target(name: x,
-      dependencies: [
-        .target(name: "TestsUtils"),
-        .target(name: "ObjectiveCTests"),
-      ],
+      dependencies: singleSourceDeps,
       path: "single-source",
       sources: ["\(x).swift"])
 }

benchmark/utils/DriverUtils.swift

@@ -370,19 +370,35 @@ final class TestRunner {
 #endif
 
   private static func getResourceUtilization() -> rusage {
-    var u = rusage(); getrusage(RUSAGE_SELF, &u); return u
+#if canImport(Darwin)
+   let rusageSelf = RUSAGE_SELF
+#else
+   let rusageSelf = RUSAGE_SELF.rawValue
+#endif
+    var u = rusage(); getrusage(rusageSelf, &u); return u
   }
 
   /// Returns maximum resident set size (MAX_RSS) delta in bytes.
   ///
   /// This method of estimating memory usage is valid only for executing single
   /// benchmark. That's why we don't worry about reseting the `baseline` in
   /// `resetMeasurements`.
+  ///
+  /// FIXME: This current implementation doesn't work on Linux. It is disabled
+  /// permanently to avoid linker errors. Feel free to fix.
   func measureMemoryUsage() -> Int? {
+#if os(Linux)
+    return nil
+#else
     guard c.logMemory else { return nil }
     let current = TestRunner.getResourceUtilization()
     let maxRSS = current.ru_maxrss - baseline.ru_maxrss
-    let pages = { maxRSS / sysconf(_SC_PAGESIZE) }
+#if canImport(Darwin)
+    let pageSize = _SC_PAGESIZE
+#else
+    let pageSize = Int32(_SC_PAGESIZE)
+#endif
+    let pages = { maxRSS / sysconf(pageSize) }
     func deltaEquation(_ stat: KeyPath<rusage, Int>) -> String {
       let b = baseline[keyPath: stat], c = current[keyPath: stat]
       return "\(c) - \(b) = \(c - b)"
@@ -394,6 +410,7 @@ final class TestRunner {
             VCS \(deltaEquation(\rusage.ru_nvcsw))
         """)
     return maxRSS
+#endif
   }
 
   private func startMeasurement() {

benchmark/utils/main.swift

@@ -96,11 +96,13 @@ import NSError
 import NSStringConversion
 import NopDeinit
 import ObjectAllocation
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
 import ObjectiveCBridging
 import ObjectiveCBridgingStubs
 #if !(SWIFT_PACKAGE || Xcode)
 import ObjectiveCNoBridgingStubs
 #endif
+#endif
 import ObserverClosure
 import ObserverForwarderStruct
 import ObserverPartiallyAppliedMethod
@@ -265,11 +267,13 @@ registerBenchmark(NSStringConversion)
 registerBenchmark(NibbleSort)
 registerBenchmark(NopDeinit)
 registerBenchmark(ObjectAllocation)
+#if os(macOS) || os(iOS) || os(watchOS) || os(tvOS)
 registerBenchmark(ObjectiveCBridging)
 registerBenchmark(ObjectiveCBridgingStubs)
 #if !(SWIFT_PACKAGE || Xcode)
 registerBenchmark(ObjectiveCNoBridgingStubs)
 #endif
+#endif
 registerBenchmark(ObserverClosure)
 registerBenchmark(ObserverForwarderStruct)
 registerBenchmark(ObserverPartiallyAppliedMethod)