Merge pull request #6 from apple/master

merge

Author: JacobMao

CMakeLists.txt

@@ -129,12 +129,12 @@ set(CLANG_COMPILER_VERSION "" CACHE STRING
     "The internal version of the Clang compiler")
 
 # Indicate whether Swift should attempt to use the lld linker.
-set(SWIFT_ENABLE_LLD_LINKER FALSE CACHE BOOL
+set(SWIFT_ENABLE_LLD_LINKER TRUE CACHE BOOL
     "Enable using the lld linker when available")
 
 # Indicate whether Swift should attempt to use the gold linker.
 # This is not used on Darwin.
-set(SWIFT_ENABLE_GOLD_LINKER FALSE CACHE BOOL
+set(SWIFT_ENABLE_GOLD_LINKER TRUE CACHE BOOL
     "Enable using the gold linker when available")
 
 set(SWIFT_SDKS "" CACHE STRING
@@ -300,6 +300,10 @@ option(SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
   "Build the standard libraries, overlays, and runtime with normal arguments at +0"
   FALSE)
 
+option(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS
+  "Enable runtime function counters and expose the API."
+  FALSE)
+
 #
 # End of user-configurable options.
 #

benchmark/scripts/Benchmark_RuntimeLeaksRunner.in

@@ -81,29 +81,35 @@ class LeaksRunnerBenchmarkDriver(perf_test_driver.BenchmarkDriver):
     def prepare_input(self, name):
         return {'num_samples': self.num_samples, 'num_iters': self.num_iters}
 
+    def run_test_inner(self, data, num_iters):
+        p = subprocess.Popen([
+            data['path'],
+            "--num-samples={}".format(data['num_samples']),
+            "--num-iters={}".format(num_iters), data['test_name']],
+            stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        error_out = p.communicate()[1].split("\n")
+        result = p.returncode
+        if result is None:
+            raise RuntimeError("Expected one line of output")
+        if result != 0:
+            raise RuntimeError("Process segfaulted")
+        return error_out
+
     def run_test(self, data, num_iters):
         try:
-            p = subprocess.Popen([
-                data['path'],
-                "--num-samples={}".format(data['num_samples']),
-                "--num-iters={}".format(num_iters), data['test_name']],
-                stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            error_out = p.communicate()[1].split("\n")
-            result = p.returncode
-            if result is None:
-                raise RuntimeError("Expected one line of output")
-            if result != 0:
-                raise RuntimeError("Process segfaulted")
-        except Exception:
-            sys.stderr.write("Child Process Failed! (%s,%s)\n" % (
-                data['path'], data['test_name']))
+            args = [data, num_iters]
+            result = perf_test_driver.run_with_timeout(self.run_test_inner,
+                                                       args)
+        except Exception, e:
+            sys.stderr.write("Child Process Failed! (%s,%s). Error: %s\n" % (
+                data['path'], data['test_name'], e))
             sys.stderr.flush()
             return None
 
         try:
             # We grab the second line since swift globals get lazily created in
             # the first iteration.
-            d = json.loads(error_out[1])
+            d = json.loads(result[1])
             d['objc_objects'] = [x for x in d['objc_objects']
                                  if x not in IGNORABLE_GLOBAL_OBJC_CLASSES]
             d['objc_count'] = len(d['objc_objects'])

benchmark/scripts/perf_test_driver/perf_test_driver.py

@@ -57,6 +57,24 @@ def print_data(self, max_test_len):
         print(fmt.format(self.get_name(), self.get_result()))
 
 
+def run_with_timeout(func, args):
+    # We timeout after 10 minutes.
+    timeout_seconds = 10 * 60
+
+    # We just use this to create a timeout since we use an older python. Once
+    # we update to use python >= 3.3, use the timeout API on communicate
+    # instead.
+    import multiprocessing.dummy
+    fakeThreadPool = multiprocessing.dummy.Pool(1)
+    try:
+        result = fakeThreadPool.apply_async(func, args=args)
+        return result.get(timeout_seconds)
+    except multiprocessing.TimeoutError:
+        fakeThreadPool.terminate()
+        raise RuntimeError("Child process aborted due to timeout. "
+                           "Timeout: %s seconds" % timeout_seconds)
+
+
 def _unwrap_self(args):
     return type(args[0]).process_input(*args)
 

benchmark/single-source/Combos.swift

@@ -18,7 +18,7 @@ public func run_Combos(_ N: Int) {
   var combos = [[Character]]()
 
   for _ in 1...10*N {
-    combos = combinations("ABCDEFGHIJ".characters, "0123456789".characters).map {
+    combos = combinations("ABCDEFGHIJ", "0123456789").map {
       return [$0] + [$1]
     }
 

benchmark/single-source/LuhnAlgoEager.swift

@@ -220,7 +220,7 @@ let combineDoubleDigits = {
 // removing lazy at start of pipeline
 // switches to array-based version
 let eagerchecksum = { (ccnum: String) -> Bool in
-    ccnum.characters//.lazy
+    ccnum //.lazy
     |> { $0.reversed().lazy }
     |> { mapSome($0, charToInt) }
     |> { mapEveryN($0, 2, double) }

benchmark/single-source/LuhnAlgoLazy.swift

@@ -219,7 +219,7 @@ let combineDoubleDigits = {
 
 // first, the lazy version of checksum calcuation
 let lazychecksum = { (ccnum: String) -> Bool in
-    ccnum.characters.lazy
+    ccnum.lazy
     |> reverse
     |> { mapSome($0, charToInt) }
     |> { mapEveryN($0, 2, double) }

benchmark/single-source/NibbleSort.swift

@@ -38,8 +38,7 @@ struct NibbleCollection: RandomAccessCollection, MutableCollection {
   let startIndex: UInt64 = 0
   let endIndex: UInt64 = 16
 
-  subscript(bounds: Range<Index>)
-  -> MutableRandomAccessSlice<NibbleCollection> {
+  subscript(bounds: Range<Index>) -> Slice<NibbleCollection> {
     get {
       fatalError("Should not be called. Added here to please the type checker")
     }

benchmark/single-source/StringRemoveDupes.swift

@@ -24,12 +24,12 @@ public func run_StringRemoveDupes(_ N: Int) {
   for _ in 1...10*N {
     s = text.removeDuplicates()
 
-    if s.characters.count != textLengthRef {
+    if s.count != textLengthRef {
       break
     }
   }
 
-  CheckResults(s.characters.count == textLengthRef)
+  CheckResults(s.count == textLengthRef)
 }
 
 // removes all but first occurrence from a sequence, returning an array.
@@ -46,6 +46,6 @@ func uniq<S: Sequence,
 // all duplicates removed
 extension String {
   func removeDuplicates() -> String {
-    return String(uniq(self.characters))
+    return String(uniq(self))
   }
 }

cmake/modules/AddSwift.cmake

@@ -255,6 +255,10 @@ function(_add_variant_c_compile_flags)
   else()
     list(APPEND result "-DNDEBUG")
   endif()
+  
+  if(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS)
+    list(APPEND result "-DSWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS")
+  endif()
 
   if(CFLAGS_ANALYZE_CODE_COVERAGE)
     list(APPEND result "-fprofile-instr-generate"
@@ -316,6 +320,10 @@ function(_add_variant_swift_compile_flags
   if (SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS)
     list(APPEND result "-Xfrontend" "-enable-guaranteed-normal-arguments")
   endif()
+  
+  if(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS)
+    list(APPEND result "-D" "SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS")
+  endif()
 
   set("${result_var_name}" "${result}" PARENT_SCOPE)
 endfunction()
@@ -396,14 +404,15 @@ function(_add_variant_link_flags)
   endif()
 
   if(NOT SWIFT_COMPILER_IS_MSVC_LIKE)
-    if(SWIFT_ENABLE_GOLD_LINKER AND
-       "${SWIFT_SDK_${LFLAGS_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
-      list(APPEND result "-fuse-ld=gold")
-    endif()
-    if(SWIFT_ENABLE_LLD_LINKER OR
+    find_program(LDLLD_PATH "ld.lld")
+    # Strangely, macOS finds lld and then can't find it when using -fuse-ld=
+    if((SWIFT_ENABLE_LLD_LINKER AND LDLLD_PATH AND NOT APPLE) OR
        ("${LFLAGS_SDK}" STREQUAL "WINDOWS" AND
         NOT "${CMAKE_SYSTEM_NAME}" STREQUAL "WINDOWS"))
       list(APPEND result "-fuse-ld=lld")
+    elseif(SWIFT_ENABLE_GOLD_LINKER AND
+       "${SWIFT_SDK_${LFLAGS_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
+      list(APPEND result "-fuse-ld=gold")
     endif()
   endif()
 
@@ -1692,12 +1701,14 @@ function(add_swift_library name)
           set(codesign_arg CODESIGN)
         endif()
         precondition(THIN_INPUT_TARGETS)
-        _add_swift_lipo_target(
-            SDK ${sdk}
-            TARGET ${lipo_target}
-            OUTPUT ${UNIVERSAL_LIBRARY_NAME}
-            ${codesign_arg}
-            ${THIN_INPUT_TARGETS})
+        _add_swift_lipo_target(SDK
+                                 ${sdk}
+                               TARGET
+                                 ${lipo_target}
+                               OUTPUT
+                                 ${UNIVERSAL_LIBRARY_NAME}
+                               ${codesign_arg}
+                               ${THIN_INPUT_TARGETS})
 
         # Cache universal libraries for dependency purposes
         set(UNIVERSAL_LIBRARY_NAMES_${SWIFT_SDK_${sdk}_LIB_SUBDIR}
@@ -1743,11 +1754,13 @@ function(add_swift_library name)
               "${name}-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-static")
           set(UNIVERSAL_LIBRARY_NAME
               "${SWIFTSTATICLIB_DIR}/${SWIFT_SDK_${sdk}_LIB_SUBDIR}/${CMAKE_STATIC_LIBRARY_PREFIX}${name}${CMAKE_STATIC_LIBRARY_SUFFIX}")
-          _add_swift_lipo_target(
-              SDK ${sdk}
-              TARGET ${lipo_target_static}
-              OUTPUT "${UNIVERSAL_LIBRARY_NAME}"
-              ${THIN_INPUT_TARGETS_STATIC})
+          _add_swift_lipo_target(SDK
+                                   ${sdk}
+                                 TARGET
+                                   ${lipo_target_static}
+                                 OUTPUT
+                                   "${UNIVERSAL_LIBRARY_NAME}"
+                                 ${THIN_INPUT_TARGETS_STATIC})
           swift_install_in_component("${SWIFTLIB_INSTALL_IN_COMPONENT}"
               FILES "${UNIVERSAL_LIBRARY_NAME}"
               DESTINATION "lib${LLVM_LIBDIR_SUFFIX}/swift_static/${resource_dir_sdk_subdir}"
@@ -1760,14 +1773,18 @@ function(add_swift_library name)
         # Add Swift standard library targets as dependencies to the top-level
         # convenience target.
         if(SWIFTLIB_TARGET_LIBRARY)
+          set(FILTERED_UNITTESTS
+                swiftStdlibCollectionUnittest
+                swiftStdlibUnicodeUnittest)
+
           foreach(arch ${SWIFT_SDK_${sdk}_ARCHITECTURES})
             set(VARIANT_SUFFIX "-${SWIFT_SDK_${sdk}_LIB_SUBDIR}-${arch}")
-            if(TARGET "swift-stdlib${VARIANT_SUFFIX}" AND TARGET "swift-test-stdlib${VARIANT_SUFFIX}")
+            if(TARGET "swift-stdlib${VARIANT_SUFFIX}" AND
+               TARGET "swift-test-stdlib${VARIANT_SUFFIX}")
               add_dependencies("swift-stdlib${VARIANT_SUFFIX}"
                   ${lipo_target}
                   ${lipo_target_static})
-              if((NOT "${name}" STREQUAL "swiftStdlibCollectionUnittest") AND
-                 (NOT "${name}" STREQUAL "swiftStdlibUnicodeUnittest"))
+              if(NOT "${name}" IN_LIST FILTERED_UNITTESTS)
                 add_dependencies("swift-test-stdlib${VARIANT_SUFFIX}"
                     ${lipo_target}
                     ${lipo_target_static})

cmake/modules/AddSwiftUnittests.cmake

@@ -47,15 +47,16 @@ function(add_swift_unittest test_dirname)
       LINK_FLAGS " -latomic")
   endif()
 
-  if(SWIFT_ENABLE_GOLD_LINKER AND
+  find_program(LDLLD_PATH "ld.lld")
+  # Strangely, macOS finds lld and then can't find it when using -fuse-ld=
+  if(SWIFT_ENABLE_LLD_LINKER AND LDLLD_PATH AND NOT APPLE)
+    set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY
+      LINK_FLAGS " -fuse-ld=lld")
+  elseif(SWIFT_ENABLE_GOLD_LINKER AND
      "${SWIFT_SDK_${SWIFT_HOST_VARIANT_SDK}_OBJECT_FORMAT}" STREQUAL "ELF")
     set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY
       LINK_FLAGS " -fuse-ld=gold")
   endif()
-  if(SWIFT_ENABLE_LLD_LINKER)
-    set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY
-      LINK_FLAGS " -fuse-ld=lld")
-  endif()
 
   if(SWIFT_ANALYZE_CODE_COVERAGE)
     set_property(TARGET "${test_dirname}" APPEND_STRING PROPERTY