Merge branch 'master' into and-dreadfully-distinct

Author: palimondo

CMakeLists.txt

@@ -180,6 +180,14 @@ option(SWIFT_ENABLE_PARSEABLE_MODULE_INTERFACES
        "Generate .swiftinterface files alongside .swiftmodule files"
        TRUE)
 
+# Allow building Swift with Clang's Profile Guided Optimization
+if(SWIFT_PROFDATA_FILE AND EXISTS ${SWIFT_PROFDATA_FILE})
+  if(NOT CMAKE_C_COMPILER_ID MATCHES Clang)
+    message(FATAL_ERROR "SWIFT_PROFDATA_FILE can only be specified when compiling with clang")
+  endif()
+  add_definitions("-fprofile-instr-use=${SWIFT_PROFDATA_FILE}")
+endif()
+
 #
 # User-configurable Android specific options.
 #
@@ -311,10 +319,6 @@ option(SWIFT_STDLIB_ENABLE_SIL_OWNERSHIP
   "Build the standard libraries and overlays with sil ownership enabled."
   FALSE)
 
-option(SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS
-  "Build the standard libraries, overlays, and runtime with normal arguments at +0"
-  TRUE)
-
 option(SWIFT_ENABLE_RUNTIME_FUNCTION_COUNTERS
   "Enable runtime function counters and expose the API."
   FALSE)
@@ -803,20 +807,17 @@ message(STATUS "Building host Swift tools for ${SWIFT_HOST_VARIANT_SDK} ${SWIFT_
 message(STATUS "  Build type:     ${CMAKE_BUILD_TYPE}")
 message(STATUS "  Assertions:     ${LLVM_ENABLE_ASSERTIONS}")
 message(STATUS "  LTO:            ${SWIFT_TOOLS_ENABLE_LTO}")
-message(STATUS "  +0 Normal Args: ${SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS}")
 message(STATUS "")
 
 if (SWIFT_BUILD_STDLIB OR SWIFT_BUILD_SDK_OVERLAY)
 
   message(STATUS "Building Swift standard library and overlays for SDKs: ${SWIFT_SDKS}")
   message(STATUS "  Build type:       ${SWIFT_STDLIB_BUILD_TYPE}")
   message(STATUS "  Assertions:       ${SWIFT_STDLIB_ASSERTIONS}")
-  message(STATUS "  +0 Normal Args:   ${SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS}")
   message(STATUS "")
 
   message(STATUS "Building Swift runtime with:")
   message(STATUS "  Leak Detection Checker Entrypoints: ${SWIFT_RUNTIME_ENABLE_LEAK_CHECKER}")
-  message(STATUS "  +0 Normal Args:                     ${SWIFT_ENABLE_GUARANTEED_NORMAL_ARGUMENTS}")
   message(STATUS "")
 
 else()
@@ -977,12 +978,24 @@ if(SWIFT_NEED_EXPLICIT_LIBDISPATCH)
   add_dependencies(dispatch libdispatch-install)
   add_dependencies(BlocksRuntime libdispatch-install)
 
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
+    set(SOURCEKIT_RUNTIME_DIR bin)
+  else()
+    set(SOURCEKIT_RUNTIME_DIR lib)
+  endif()
   swift_install_in_component(sourcekit-inproc
                              FILES
                                $<TARGET_FILE:dispatch>
                                $<TARGET_FILE:BlocksRuntime>
-                             DESTINATION
-                               lib${LLVM_LIBDIR_SUFFIX})
+                             DESTINATION ${SOURCEKIT_RUNTIME_DIR})
+  if(SWIFT_HOST_VARIANT_SDK STREQUAL WINDOWS)
+    swift_install_in_component(sourcekit-inproc
+                               FILES
+                                 $<TARGET_LINKER_FILE:dispatch>
+                                 $<TARGET_LINKER_FILE:BlocksRuntime>
+                               DESTINATION lib)
+  endif()
+
 
   # FIXME(compnerd) this should be taken care of by the
   # INTERFACE_INCLUDE_DIRECTORIES above

README.md

@@ -72,7 +72,7 @@ supported host development operating systems.
 
 #### macOS
 
-To build for macOS, you need [Xcode 10.0](https://developer.apple.com/xcode/downloads/).
+To build for macOS, you need [Xcode 10.2 beta](https://developer.apple.com/xcode/downloads/).
 The required version of Xcode changes frequently, and is often a beta release.
 Check this document or the host information on <https://ci.swift.org> for the
 current required version.

apinotes/CMakeLists.txt

@@ -28,6 +28,10 @@ add_custom_target("copy_apinotes"
     COMMENT "Copying API notes to ${output_dir}"
     SOURCES "${sources}")
 
+# This is treated as an OPTIONAL target because if we don't build the SDK
+# overlay, the files will be missing anyway. It also allows us to build
+# single overlays without installing the API notes.
 swift_install_in_component(sdk-overlay
-    FILES ${sources}
-    DESTINATION "lib/swift/apinotes")
+    DIRECTORY "${output_dir}"
+    DESTINATION "lib/swift/"
+    OPTIONAL)

benchmark/CMakeLists.txt

@@ -58,7 +58,6 @@ set(SWIFT_BENCH_MODULES
     single-source/ClassArrayGetter
     single-source/Codable
     single-source/Combos
-    single-source/CountAlgo
     single-source/DataBenchmarks
     single-source/DeadArray
     single-source/DictOfArraysToArrayOfDicts

benchmark/README.md

@@ -132,12 +132,17 @@ Adding New Benchmarks
 
 The harness generator supports both single and multiple file tests.
 
-To add a new single file test:
+To add a new single file test, execute the following script with the new of the benchmark:
 
+```
+swift-source$ ./swift/benchmark/scripts/create_benchmark.py YourTestNameHere
+```
+
+The script will automatically:
 1.  Add a new Swift file (`YourTestNameHere.swift`), built according to
     the template below, to the `single-source` directory.
-2.  Add the filename of the new Swift file to CMakeLists.txt
-3.  Edit `main.swift`. Import and register your new Swift module.
+2.  Add the filename of the new Swift file to `CMakeLists.txt`.
+3.  Edit `main.swift` by importing and registering your new Swift module.
 
 To add a new multiple file test:
 

benchmark/multi-source/PrimsSplit/Prims_main.swift

@@ -15,11 +15,12 @@ import TestsUtils
 public let PrimsSplit = BenchmarkInfo(
   name: "PrimsSplit",
   runFunction: run_PrimsSplit,
-  tags: [.validation, .algorithm])
+  tags: [.validation, .algorithm],
+  legacyFactor: 5)
 
 @inline(never)
 public func run_PrimsSplit(_ N: Int) {
-  for _ in 1...5*N {
+  for _ in 1...N {
     let nodes : [Int] = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12,
       13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
       29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,

benchmark/scripts/Template.swift

@@ -0,0 +1,22 @@
+//===--- {name}.swift -------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2019 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import TestsUtils
+
+public let {name} = [
+  BenchmarkInfo(name: "{name}", runFunction: run_{name}, tags: [.validation, .api]),
+]
+
+@inline(never)
+public func run_{name}(N: Int) {{
+    // TODO
+}}

benchmark/scripts/create_benchmark.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python
+
+import argparse
+import os
+import re
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument('name', help='The name of the new benchmark to be created')
+    args = p.parse_args()
+
+    # adds benchmark to `CMakeLists.txt`
+    update_cmakelists(args.name)
+    # create benchmark Swift file
+    create_benchmark_file(args.name)
+    # imports the benchmark module in `main.swift`
+    add_import_benchmark(args.name)
+    # registers the benchmark with the driver in `main.swift`
+    add_register_benchmark(args.name)
+
+
+def update_cmakelists(name):
+    """Adds a new entry to the `CMakeLists.txt` file with the given
+    benchmark name.
+    """
+    relative_path = create_relative_path('../CMakeLists.txt')
+
+    file_contents = []
+    with open(relative_path, 'r') as f:
+        file_contents = f.readlines()
+
+    file_new_contents = insert_line_alphabetically(
+        name,
+        '    single-source/' + name + '\n',
+        file_contents,
+        r"    single-source\/([a-zA-Z]+)"
+    )
+    with open(relative_path, 'w') as f:
+        for line in file_new_contents:
+            f.write(line)
+
+
+def create_benchmark_file(name):
+    """Creates a new Swift file with the given name based on the template
+    and places it in the `single-source` directory.
+    """
+
+    template_path = create_relative_path('Template.swift')
+    benchmark_template = ''
+    with open(template_path, 'r') as f:
+        benchmark_template = ''.join(f.readlines())
+
+    # fill in template with benchmark name.
+    formatted_template = benchmark_template.format(name=name)
+
+    relative_path = create_relative_path('../single-source/')
+    source_file_path = os.path.join(relative_path, name + '.swift')
+    with open(source_file_path, 'w') as f:
+        f.write(formatted_template)
+
+
+def add_import_benchmark(name):
+    """Adds an `import` statement to the `main.swift` file for the new 
+    benchmark.
+    """
+    relative_path = create_relative_path('../utils/main.swift')
+
+    # read current contents into an array
+    file_contents = []
+    with open(relative_path, 'r') as f:
+        file_contents = f.readlines()
+
+    # the test dependencies are placed before all benchmarks, so we have to 
+    # insert the benchmark in the right alphabetical order after we have seen
+    # all test dependencies.
+    read_test_dependencies = False
+    previous_benchmark_name = None
+    file_new_contents = []
+    for line in file_contents:
+        # check if this line is a definition of a benchmark and get its name
+        match = re.search(r"import ([a-zA-Z]+)", line)
+        if match and match.group(1):
+            benchmark_name = match.group(1)
+            # find where to insert the new benchmark in the right alphabetical 
+            # order.
+            if (name < benchmark_name and previous_benchmark_name is None or
+                    name < benchmark_name and name > previous_benchmark_name):
+                if read_test_dependencies:
+                    file_new_contents.append('import ' + name + '\n' + line)
+                else:
+                    # all test dependencies are first specified, so from now 
+                    # on we can look where to insert the new benchmark.
+                    read_test_dependencies = True
+                    file_new_contents.append(line)
+            else:
+                file_new_contents.append(line)    
+            previous_benchmark_name = benchmark_name
+        else:
+            file_new_contents.append(line)
+    with open(relative_path, 'w') as f:
+        for line in file_new_contents:
+            f.write(line)
+
+
+def add_register_benchmark(name):
+    """Adds an `import` statement to the `main.swift` file for the new
+    benchmark.
+    """
+    relative_path = create_relative_path('../utils/main.swift')
+
+    file_contents = []
+    with open(relative_path, 'r') as f:
+        file_contents = f.readlines()
+
+    file_new_contents = insert_line_alphabetically(
+        name,
+        'registerBenchmark(' + name + ')\n',
+        file_contents, 
+        r"registerBenchmark\(([a-zA-Z]+)\)"
+    )
+    with open(relative_path, 'w') as f:
+        for line in file_new_contents:
+            f.write(line)
+
+
+def insert_line_alphabetically(name, new_line, lines, regex):
+    """Iterates through the given lines and executes the regex on each line to
+    find where the new benchmark should be inserted with the given `new_line`.
+    """
+    # the name of the previous seen benchmark in order to insert the new
+    # one at the correct position 
+    previous_benchmark_name = None
+    # the new contents of the file
+    updated_lines = []
+    for line in lines:
+        # apply regex and get name of benchmark on this line
+        match = re.search(regex, line)
+        if match and match.group(1):
+            benchmark_name = match.group(1)
+            # check if we're at the line where we have to insert the new
+            # benchmark in the correct alphabetical order
+            if (name < benchmark_name and previous_benchmark_name is None or 
+                    name < benchmark_name and name > previous_benchmark_name):
+                updated_lines.append(new_line + line)
+            else:
+                updated_lines.append(line)    
+            previous_benchmark_name = benchmark_name
+        else:
+            updated_lines.append(line)
+    return updated_lines
+
+
+def create_relative_path(file_path):
+    return os.path.join(os.path.dirname(__file__), file_path)
+
+
+if __name__ == "__main__":
+    main()

benchmark/scripts/run_smoke_bench

@@ -185,7 +185,7 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
     tests = TestComparator(results[0], results[1], threshold)
     changed = tests.decreased + tests.increased
 
-    while len(changed) > 0 and unchanged_length_count < 5:
+    while len(changed) > 0 and unchanged_length_count < 10:
         i += 1
         if VERBOSE:
             log('        test again: ' + str([test.name for test in changed]))
@@ -205,25 +205,6 @@ def test_performance(opt_level, old_dir, new_dir, threshold, num_samples,
                           threshold * 1.4, output_file, *results)
 
 
-def get_results(bench_dir, opt_level, num_samples, to_test):
-    try:
-        exe = os.path.join(bench_dir, 'bin', 'Benchmark_' + opt_level)
-        args = [exe, '--num-samples=' + str(num_samples),
-                '--sample-time=0.0025']
-        if to_test:
-            args += to_test
-        env = {'DYLD_LIBRARY_PATH': os.path.join(bench_dir, 'lib', 'swift',
-               'macos'),
-               'SWIFT_DETERMINISTIC_HASHING': '1'}
-        output = subprocess.check_output(args, env=env)
-    except subprocess.CalledProcessError as e:
-        sys.stderr.write(e.output)
-        sys.stderr.flush()
-        return sys.exit(e.returncode)
-    else:
-        return output
-
-
 def report_code_size(opt_level, old_dir, new_dir, platform, output_file):
     if opt_level == 'swiftlibs':
         files = glob.glob(os.path.join(old_dir, 'lib', 'swift', platform,