[lldb] Introduce a tool to quickly generate projects with an arbitrary number of sources

[bulbazord]

Summary

The purpose of this tool is to be able to generate a project with an
arbitrary number of source files in a given programming language. I
believe this can be useful as it lets you benchmark a given LLDB change
for performance locally. For example, if you are changing the way LLDB
processes a specific debug info section, you may want to make sure that
you're not regressing performance (or if you're making the change for
performance, you want to ensure that it actually improves things). You
could use this tool to generate 10,000 (or more) source files and see
how quickly lldb processes the debug info of the resulting binary.

I understand that many folks will measure performance changes against
large projects, usually proprietary in nature. I believe this is quite a
valid way to measure performance changes and this tool isn't meant to
change that. I wanted to offer this tool primarily as an alternative
that gives the developer more control over the size and contents of the
project (which is not something you always have when working with
proprietary projects).

Currently this tool only supports C, C++, and Swift. The Swift portions will
only work on macOS right now and will not work with upstream lldb. There are
also multiple ways to build Swift projects, this just chooses one specific
approach. Future work could include adding an option to choose the structure of
the generated Swift project.

[aprantl]

That looks useful!

lldb/scripts/generate-project.py

176

Would """ multiline literals be more readable?

[kastiglione]

lldb/scripts/generate-project.py

119–127

minor, but I noticed some of these f-strings don't have an {} interpolation.

176

+1

[kastiglione]

lldb/scripts/generate-project.py

70

117

[bulbazord]

• Converted some things to use multiline string literals
• Converted some f-strings into string literals when they didn't need interpolation
• Applied black formatting

[bulbazord]

lldb/scripts/generate-project.py

176

I changed it, what do y'all think?

[mib]

lldb/scripts/generate-project.py

24

nit: Is it necessary to put it in a variable or could you have a multiline string in the write call ?

184–191

What about here ?

[DavidSpickett]

If you wanted to indent the long strings to the same level as the function's code you could use https://docs.python.org/3/library/textwrap.html#textwrap.dedent (but it's fine as is).

[bulbazord]

Remove temp variables
More multiline string literals

[kastiglione]

lldb/scripts/generate-project.py

21

os.path.join to be windows friendly?

[kastiglione]

lldb/scripts/generate-project.py

21

I just noticed the contents of the makefiles also have forward slashes, so I retract my comment.

[bulbazord]

If nobody else has any comments, I plan on landing this tomorrow.

[clayborg]

lldb/scripts/generate-project.py

21

I would vote to use os.path.join() instead of manually formatting strings

50

Add a "PP" to differentiate from c?

297–301

move into generate_sources(...)?

lldb/scripts/generate-project.py

+#!/usr/bin/env python3
+
+# Project generation script
+# =========================
+# The purpose of this script is to generate a project with an arbitrary amount
+# of source files. This is useful for testing the performance impact of a given
+# LLDB change. For example, you can use this tool to generate a project with
+# 10,000 C++ source files and see how quickly LLDB processes the resulting
+# binary and related metadata (e.g. debug info).
+
+import os
+import sys
+import typing
+
+
+def print_usage() -> None:
+    print("Usage: generate-project.py <number of objects> <language> <destination>")
+
+
+def generate_c_header(directory: str, index: int) -> None:
+    header_path = f"{directory}/obj{index}.h"
+    with open(header_path, "w") as f:
+        f.write(
+            f"#ifndef _OBJ{index}_H\n"
+            f"#define _OBJ{index}_H\n"
+            f"extern int obj{index};\n"
+            f"void call_obj{index}(void);\n"
+            f"#endif // _OBJ{index}_H\n"
+        )
+
+
+def generate_c_impl(directory: str, index: int) -> None:
+    impl_path = f"{directory}/obj{index}.c"
+    with open(impl_path, "w") as f:
+        f.write(
+            "#include <stdio.h>\n"
+            f'#include "obj{index}.h"\n\n'
+            f"int obj{index} = {index};\n"
+            f"void call_obj{index}(void)"
+            " {\n"
+            f'  printf("%d\\n", obj{index});\n'
+            "}\n"
+        )
+
+
+def generate_cpp_header(directory: str, index: int) -> None:
+    header_path = f"{directory}/obj{index}.h"
+    with open(header_path, "w") as f:
+        f.write(
+            f"#ifndef _OBJ{index}_H\n"
+            f"#define _OBJ{index}_H\n"
+            "namespace obj {\n"
+            f"class Obj{index}"
+            " {\n"
+            "public:\n"
+            "  static void Call(void);\n"
+            "}; // class\n"
+            "} // namespace\n"
+            f"#endif // _OBJ{index}_H\n"
+        )
+
+
+def generate_cpp_impl(directory: str, index: int) -> None:
+    impl_path = f"{directory}/obj{index}.cpp"
+    with open(impl_path, "w") as f:
+        f.write(
+            "#include <iostream>\n"
+            f'#include "obj{index}.h"\n\n'
+            "namespace obj {\n"
+            f"void Obj{index}::Call(void)"
+            " {\n"
+            f"  std::cout << {index} << std::endl;;\n"
+            "}\n"
+            "} // namespace\n"
+        )
+
+
+def generate_swift_impl(directory: str, index: int) -> None:
+    impl_path = f"{directory}/obj{index}.swift"
+    with open(impl_path, "w") as f:
+        f.write(f"public func call_obj{index}()" " {\n" f'  print("{index}")\n' "}\n")
+
+
+def generate_c_driver(directory: str, number_of_objects: int) -> None:
+    main_path = f"{directory}/main.c"
+    with open(main_path, "w") as f:
+        for i in range(number_of_objects):
+            f.write(f'#include "obj{i}.h"\n')
+
+        f.write("int main() {\n")
+        for i in range(number_of_objects):
+            f.write(f"  call_obj{i}();\n")
+
+        f.write("  return 0;\n")
+        f.write("}\n")
+
+
+def generate_cpp_driver(directory: str, number_of_objects: int) -> None:
+    main_path = f"{directory}/main.cpp"
+    with open(main_path, "w") as f:
+        for i in range(number_of_objects):
+            f.write(f'#include "obj{i}.h"\n')
+
+        f.write("using namespace obj;\n")
+        f.write("int main() {\n")
+        for i in range(number_of_objects):
+            f.write(f"  Obj{i}::Call();\n")
+
+        f.write("  return 0;\n")
+        f.write("}\n")
+
+
+def generate_swift_driver(directory: str, number_of_objects: int) -> None:
+    main_path = f"{directory}/main.swift"
+    with open(main_path, "w") as f:
+        for i in range(number_of_objects):
+            f.write(f"import obj{i}\n")
+
+        f.write("public func main() {\n")
+        for i in range(number_of_objects):
+            f.write(f"  call_obj{i}()\n")
+        f.write("}\n")
+        f.write("main()\n")
+
+
+def generate_c_makefile(directory: str, number_of_objects: int) -> None:
+    makefile_path = f"{directory}/Makefile"
+    with open(makefile_path, "w") as f:
+        f.write("OBJDIR=objs\n\n")
+        f.write("objects = \\\n")
+        for i in range(number_of_objects):
+            f.write(f"  $(OBJDIR)/obj{i}.o \\\n")
+        f.write("  $(OBJDIR)/main.o\n")
+        f.write("\n")
+        f.write(
+            """
+all: many-objects
+objdir:
+\tmkdir -p $(OBJDIR)
+$(OBJDIR)/%.o: %.c objdir
+\t$(CC) -g -c -o $@ $<
+many-objects: $(objects)
+\t$(CC) -g -o $@ $^
+clean:
+\trm -rf objs/ many-objects
+"""
+        )
+
+
+def generate_cpp_makefile(directory: str, number_of_objects: int) -> None:
+    makefile_path = f"{directory}/Makefile"
+    with open(makefile_path, "w") as f:
+        f.write("OBJDIR=objs\n\n")
+        f.write("objects = \\\n")
+        for i in range(number_of_objects):
+            f.write(f"  $(OBJDIR)/obj{i}.o \\\n")
+        f.write("  $(OBJDIR)/main.o\n")
+        f.write("\n")
+        f.write(
+            """
+all: many-objects
+objdir:
+\tmkdir -p $(OBJDIR)
+$(OBJDIR)/%.o: %.cpp objdir
+\t$(CXX) -g -c -o $@ $<
+many-objects: $(objects)
+\t$(CXX) -g -o $@ $^
+clean:
+\trm -rf objs/ many-objects
+"""
+        )
+
+
+def generate_swift_makefile(directory: str, number_of_objects: int) -> None:
+    makefile_path = f"{directory}/Makefile"
+    with open(makefile_path, "w") as f:
+        # Definitions
+        f.write(
+            """
+OBJDIR=objs
+SDK=$(shell xcrun --show-sdk-path)
+SWIFT_FE=swift -frontend
+SWIFT_FEFLAGS=-g -Onone -serialize-debugging-options \\
+  -sdk $(SDK) -enable-anonymous-context-mangled-names
+SWIFTC=swiftc
+objects = \\
+"""
+        )
+        for i in range(number_of_objects - 1):
+            f.write(f"  $(OBJDIR)/obj{i}.o \\\n")
+        f.write(f"  $(OBJDIR)/obj{number_of_objects - 1}.o\n")
+        f.write("\n")
+
+        f.write(
+            """
+all: many-objects
+objdir:
+\tmkdir -p $(OBJDIR)
+clean:
+\trm -rf objs/ many-objects
+
+$(OBJDIR)/%.o: %.swift objdir
+\t$(SWIFT_FE) -c -primary-file $< -I objs/ \\
+\t  $(SWIFT_FEFLAGS) -module-name $(patsubst %.swift,%,$<) \\
+\t  $(if $(filter-out main.swift,$<),-parse-as-library) \\
+\t  -emit-module-path $(patsubst %.o,%.partial.swiftmodule,$@) \\
+\t  -o $@
+\t$(SWIFT_FE) $(SWIFT_FEFLAGS) -merge-modules \\
+\t  -emit-module -emit-module-interface-path \\
+\t  $(patsubst %.o,%.swiftinterface,$@) \\
+\t  $(patsubst %.o,%.partial.swiftmodule,$@) \\
+\t  -disable-diagnostic-passes -disable-sil-perf-optzns\\
+\t  -module-name $(patsubst %.swift,%,$<) \\
+\t  -o $(patsubst %.o,%.swiftmodule,$@)
+
+$(OBJDIR)/main.o: main.swift $(objects)
+\t$(SWIFT_FE) -c -primary-file $< -I objs/ \\
+\t  $(SWIFT_FEFLAGS) -module-name main \\
+\t  -emit-module-path $(patsubst %.o,%.partial.swiftmodule,$@) \\
+\t  -o $@
+\t$(SWIFT_FE) $(SWIFT_FEFLAGS) -merge-modules \\
+\t  -emit-module -emit-module-interface-path \\
+\t  $(patsubst %.o,%.swiftinterface,$@) \\
+\t  $(patsubst %.o,%.partial.swiftmodule,$@) \\
+\t  -disable-diagnostic-passes -disable-sil-perf-optzns\\
+\t  -module-name $(patsubst %.swift,%,$<) \\
+\t  -o $(patsubst %.o,%.swiftmodule,$@)
+
+many-objects: $(OBJDIR)/main.o $(objects)
+\t$(SWIFTC) -Onone -Xfrontend -serialize-debugging-options \\
+\t  -sdk $(SDK) -o $@ $^
+"""
+        )
+
+
+def generate_sources_c(number_of_objects: int, generated_dir: str) -> None:
+    for i in range(number_of_objects):
+        generate_c_header(generated_dir, i)
+        generate_c_impl(generated_dir, i)
+
+    generate_c_driver(generated_dir, number_of_objects)
+    generate_c_makefile(generated_dir, number_of_objects)
+
+
+def generate_sources_cpp(number_of_objects: int, generated_dir: str) -> None:
+    for i in range(number_of_objects):
+        generate_cpp_header(generated_dir, i)
+        generate_cpp_impl(generated_dir, i)
+
+    generate_cpp_driver(generated_dir, number_of_objects)
+    generate_cpp_makefile(generated_dir, number_of_objects)
+
+
+def generate_sources_swift(number_of_objects: int, generated_dir: str) -> None:
+    for i in range(number_of_objects):
+        generate_swift_impl(generated_dir, i)
+
+    generate_swift_driver(generated_dir, number_of_objects)
+    generate_swift_makefile(generated_dir, number_of_objects)
+
+
+def generate_sources(number_of_objects: int, language: str, destination: str) -> None:
+    if os.path.exists(destination):
+        print("Directory already exists, please delete or rename it")
+        sys.exit(1)
+
+    os.mkdir(destination)
+    generation_funcs = {
+        "c": generate_sources_c,
+        "cpp": generate_sources_cpp,
+        "swift": generate_sources_swift,
+    }
+    generation_funcs[language](number_of_objects, destination)
+
+
+if __name__ == "__main__":
+    # TODO: If we want to add more arguments, it might be better to add a proper
+    # argparser to this tool.
+    if len(sys.argv) != 4:
+        print_usage()
+        sys.exit(1)
+
+    try:
+        number_of_objects = int(sys.argv[1])
+    except Exception:
+        print("Error: Unable to convert argv[1] to number")
+        print_usage()
+        sys.exit(1)
+
+    language = sys.argv[2]
+    destination = sys.argv[3]
+    if number_of_objects < 1:
+        print("Can't generate less than 1 object(s)")
+        print_usage()
+        sys.exit(1)
+
+    supported_languages = ["c", "cpp", "swift"]
+    if language not in supported_languages:
+        print(f"Unrecognized language: {language}")
+        print(f"Supported languages: {supported_languages}")
+        sys.exit(1)
+
+    generate_sources(number_of_objects, language, destination)