เชนเครื่องมือ

หน้านี้อธิบายเฟรมเวิร์ก Toolchain ซึ่งเป็นวิธีที่ผู้เขียนกฎแยกตรรกะกฎออกจากการเลือกเครื่องมือตามแพลตฟอร์ม ขอแนะนำให้อ่านหน้ากฎและแพลตฟอร์มก่อนดำเนินการต่อ หน้านี้จะอธิบายถึงเหตุผลที่ต้องใช้โซ่เครื่องมือ วิธีการกำหนดและใช้งาน และวิธีที่ Bazel เลือก Toolchain ที่เหมาะสมตามข้อจำกัดของแพลตฟอร์ม

แรงจูงใจ

ก่อนอื่นมาพิจารณาปัญหาที่เครื่องมือทางเทคนิคออกแบบมาเพื่อแก้ปัญหา สมมติว่าคุณกำลังเขียนกฎเพื่อรองรับภาษาโปรแกรมแบบ "bar" กฎ bar_binary จะรวบรวมไฟล์ *.bar โดยใช้คอมไพเลอร์ barc ซึ่งเป็นเครื่องมือที่สร้างขึ้นเองเป็นเป้าหมายอีกอย่างหนึ่งในพื้นที่ทำงาน เนื่องจากผู้ใช้ที่เขียนเป้าหมาย bar_binary ไม่ควรต้องระบุทรัพยากร Dependency ในคอมไพเลอร์ จึงเป็นการกำหนดให้ทรัพยากร Dependency แบบโดยนัยโดยเพิ่มไปในคำจำกัดความของกฎเป็นแอตทริบิวต์ส่วนตัว

bar_binary = rule(
    implementation = _bar_binary_impl,
    attrs = {
        "srcs": attr.label_list(allow_files = True),
        ...
        "_compiler": attr.label(
            default = "//bar_tools:barc_linux",  # the compiler running on linux
            providers = [BarcInfo],
        ),
    },
)

ตอนนี้ //bar_tools:barc_linux จะเป็นทรัพยากรที่ต้องพึ่งพาของเป้าหมาย bar_binary ทั้งหมด ดังนั้นระบบจะสร้าง //bar_tools:barc_linux ก่อนเป้าหมาย bar_binary โดยฟังก์ชันการใช้งานของกฎ จะเข้าถึงแอตทริบิวต์นี้ได้เช่นเดียวกับแอตทริบิวต์อื่นๆ

BarcInfo = provider(
    doc = "Information about how to invoke the barc compiler.",
    # In the real world, compiler_path and system_lib might hold File objects,
    # but for simplicity they are strings for this example. arch_flags is a list
    # of strings.
    fields = ["compiler_path", "system_lib", "arch_flags"],
)

def _bar_binary_impl(ctx):
    ...
    info = ctx.attr._compiler[BarcInfo]
    command = "%s -l %s %s" % (
        info.compiler_path,
        info.system_lib,
        " ".join(info.arch_flags),
    )
    ...

ปัญหาที่เกิดขึ้นคือมีการเขียนป้ายกำกับคอมไพเลอร์ลงใน bar_binary แต่เป้าหมายที่แตกต่างกันอาจต้องใช้คอมไพเลอร์ที่แตกต่างกัน ทั้งนี้ขึ้นอยู่กับแพลตฟอร์มที่สร้างและแพลตฟอร์มที่ใช้สร้าง ซึ่งเรียกว่าแพลตฟอร์มเป้าหมายและแพลตฟอร์มการเรียกใช้ตามลำดับ นอกจากนี้ ผู้เขียนกฎไม่จำเป็นต้องรู้จักเครื่องมือและแพลตฟอร์มที่มีอยู่ทั้งหมดด้วย ดังนั้นการฮาร์ดโค้ดเครื่องมือและแพลตฟอร์มในคำจำกัดความของกฎเป็นไปไม่ได้

ทางออกที่ไม่ค่อยดีที่สุดคือสร้างภาระให้ผู้ใช้ โดยทำให้แอตทริบิวต์ _compiler เป็นแบบไม่เป็นส่วนตัว จากนั้นจึงสามารถกําหนดเป้าหมายแต่ละรายการแบบฮาร์ดโค้ดเพื่อสร้างสําหรับแพลตฟอร์มใดแพลตฟอร์มหนึ่ง

bar_binary(
    name = "myprog_on_linux",
    srcs = ["mysrc.bar"],
    compiler = "//bar_tools:barc_linux",
)

bar_binary(
    name = "myprog_on_windows",
    srcs = ["mysrc.bar"],
    compiler = "//bar_tools:barc_windows",
)

คุณปรับปรุงโซลูชันนี้ได้โดยใช้ select เพื่อเลือก compiler ตามแพลตฟอร์ม ดังนี้

config_setting(
    name = "on_linux",
    constraint_values = [
        "@platforms//os:linux",
    ],
)

config_setting(
    name = "on_windows",
    constraint_values = [
        "@platforms//os:windows",
    ],
)

bar_binary(
    name = "myprog",
    srcs = ["mysrc.bar"],
    compiler = select({
        ":on_linux": "//bar_tools:barc_linux",
        ":on_windows": "//bar_tools:barc_windows",
    }),
)

แต่วิธีนี้ค่อนข้างยุ่งยากและเป็นการขอมากเกินไปสำหรับผู้ใช้ bar_binary ทุกคน หากไม่ได้ใช้รูปแบบนี้อย่างสอดคล้องกันทั่วทั้งพื้นที่ทำงาน จะนำไปสู่การสร้างที่ทำงานได้ดีในแพลตฟอร์มเดียวแต่ล้มเหลวเมื่อขยายไปใช้กับสถานการณ์หลายแพลตฟอร์ม นอกจากนี้ ก็ไม่ได้ช่วยแก้ปัญหาในการเพิ่มการรองรับแพลตฟอร์มและคอมไพเลอร์ใหม่โดยไม่แก้ไขกฎหรือเป้าหมายที่มีอยู่

เฟรมเวิร์กเครื่องมือเชนจะแก้ปัญหานี้ด้วยการเพิ่มการเปลี่ยนเส้นทางทางอ้อมอีกระดับ โดยพื้นฐานแล้ว คุณประกาศว่ากฎมีทรัพยากร Dependency แบบนามธรรมกับสมาชิกบางคนในกลุ่มเป้าหมาย (ประเภท Toolchain) และ Bazel จะแก้ไขปัญหานี้โดยอัตโนมัติสำหรับเป้าหมายที่เฉพาะเจาะจง (เครื่องมือเชน) โดยอิงตามข้อจำกัดของแพลตฟอร์มที่เกี่ยวข้อง ผู้เขียนกฎและผู้เขียนเป้าหมายไม่จำเป็นต้องทราบแพลตฟอร์มและชุดเครื่องมือทั้งหมดที่ใช้ได้

การเขียนกฎที่ใช้เครื่องมือทางเทคนิค

ในเฟรมเวิร์กเครื่องมือทํางาน กฎจะขึ้นอยู่กับประเภทเครื่องมือทํางานแทนที่จะขึ้นอยู่กับเครื่องมือโดยตรง ประเภท Toolchain คือเป้าหมายง่ายๆ ที่แสดงถึงคลาสของเครื่องมือที่ทำงานเดียวกันสำหรับแพลตฟอร์มต่างๆ เช่น คุณประกาศประเภทที่แสดงถึงคอมไพเลอร์แถบได้ ดังนี้

# By convention, toolchain_type targets are named "toolchain_type" and
# distinguished by their package path. So the full path for this would be
# //bar_tools:toolchain_type.
toolchain_type(name = "toolchain_type")

มีการแก้ไขคำจำกัดความของกฎในส่วนก่อนหน้า เพื่อให้แทนที่จะใส่ในคอมไพเลอร์เป็นแอตทริบิวต์ ระบบจะประกาศว่ามีการใช้ Toolchain ของ //bar_tools:toolchain_type

bar_binary = rule(
    implementation = _bar_binary_impl,
    attrs = {
        "srcs": attr.label_list(allow_files = True),
        ...
        # No `_compiler` attribute anymore.
    },
    toolchains = ["//bar_tools:toolchain_type"],
)

ตอนนี้ฟังก์ชันการใช้งานจะเข้าถึงทรัพยากร Dependency นี้ในส่วน ctx.toolchains แทน ctx.attr แล้ว โดยใช้ประเภท Toolchain เป็นคีย์

def _bar_binary_impl(ctx):
    ...
    info = ctx.toolchains["//bar_tools:toolchain_type"].barcinfo
    # The rest is unchanged.
    command = "%s -l %s %s" % (
        info.compiler_path,
        info.system_lib,
        " ".join(info.arch_flags),
    )
    ...

ctx.toolchains["//bar_tools:toolchain_type"] จะแสดงผล ToolchainInfo ผู้ให้บริการ ของใดก็ตามที่ Bazel เป้าหมายได้แก้ไขทรัพยากร Dependency ของ Toolchain ช่องของออบเจ็กต์ ToolchainInfo จะกำหนดโดยกฎของเครื่องมือที่สำคัญ และในส่วนถัดไป กฎนี้จะกำหนดให้มีช่อง barcinfo ที่รวมออบเจ็กต์ BarcInfo อยู่

ขั้นตอนของ Bazel ในการแก้ไขชุดเครื่องมือไปยังเป้าหมายมีอธิบายไว้ด้านล่าง มีเพียงเป้าหมายเครื่องมือทางเทคนิคที่แก้ไขแล้วเท่านั้นที่จะเป็นทรัพยากรของเป้าหมาย bar_binary ไม่ใช่พื้นที่ทั้งหมดของเครื่องมือทางเทคนิคที่เป็นไปได้

เครื่องมือที่จำเป็นและไม่จำเป็น

โดยค่าเริ่มต้น เมื่อกฎแสดงทรัพยากร Dependency ของประเภท Toolchain โดยใช้ป้ายกำกับเปล่า (ดังที่แสดงด้านบน) ระบบจะถือว่าประเภท Toolchain เป็นบังคับ หาก Bazel ไม่พบ Toolchain ที่ตรงกัน (ดูการแก้ไข Toolchain ด้านล่าง) สำหรับประเภท Toolchain ที่ต้องระบุ การวิเคราะห์จะหยุดลงและแสดงข้อผิดพลาด

คุณประกาศการพึ่งพาประเภทเครื่องมือทางเทคนิคที่ไม่บังคับแทนได้ ดังนี้

bar_binary = rule(
    ...
    toolchains = [
        config_common.toolchain_type("//bar_tools:toolchain_type", mandatory = False),
    ],
)

เมื่อแก้ไขประเภท Toolchain ที่ไม่บังคับไม่ได้ การวิเคราะห์จะดำเนินต่อไป และผลลัพธ์ของ ctx.toolchains["//bar_tools:toolchain_type"] คือ None

ฟังก์ชัน config_common.toolchain_type จะเป็นแบบต้องระบุโดยค่าเริ่มต้น

คุณใช้แบบฟอร์มต่อไปนี้ได้

• ประเภท Toolchain ที่จำเป็นมีดังนี้
  • toolchains = ["//bar_tools:toolchain_type"]
  • toolchains = [config_common.toolchain_type("//bar_tools:toolchain_type")]
  • toolchains = [config_common.toolchain_type("//bar_tools:toolchain_type", mandatory = True)]
• ประเภทเครื่องมือทางเทคนิคที่ไม่บังคับ
  • toolchains = [config_common.toolchain_type("//bar_tools:toolchain_type", mandatory = False)]

bar_binary = rule(
    ...
    toolchains = [
        "//foo_tools:toolchain_type",
        config_common.toolchain_type("//bar_tools:toolchain_type", mandatory = False),
    ],
)

นอกจากนี้ยังผสมผสานแบบฟอร์มในกฎเดียวกันได้ด้วย อย่างไรก็ตาม หากมีการแสดงเครื่องมือประเภทเดียวกันหลายครั้ง ระบบจะใช้เวอร์ชันที่เข้มงวดที่สุด เนื่องจากข้อบังคับมีความเข้มงวดมากกว่าตัวเลือกที่ไม่บังคับ

การเขียนด้านต่างๆ ที่ใช้ Toolchain

Aspect มีสิทธิ์เข้าถึง Toolchain API เดียวกับกฎ โดยคุณสามารถกำหนดประเภท Toolchain ที่จำเป็น เข้าถึง Toolchain ผ่านบริบท และใช้ในการสร้างการกระทำใหม่ด้วย Toolchain

bar_aspect = aspect(
    implementation = _bar_aspect_impl,
    attrs = {},
    toolchains = ['//bar_tools:toolchain_type'],
)

def _bar_aspect_impl(target, ctx):
  toolchain = ctx.toolchains['//bar_tools:toolchain_type']
  # Use the toolchain provider like in a rule.
  return []

การกำหนด Toolchain

คุณต้องมี 3 สิ่งต่อไปนี้เพื่อกำหนด Toolchain บางประเภทสำหรับประเภท Toolchain ที่กำหนด

1. กฎเฉพาะภาษาที่แสดงถึงประเภทเครื่องมือหรือชุดเครื่องมือ โดยทั่วไปแล้ว ชื่อของกฎนี้จะต่อท้ายด้วย "_toolchain"

   1. หมายเหตุ: กฎ \_toolchain สร้างการดำเนินการสร้างไม่ได้ แต่รวบรวมรายการต่างๆ จากกฎอื่นๆ และส่งต่อไปยังกฎที่ใช้เครื่องมือทางเทคนิค กฎนั้นมีหน้าที่สร้าง การดำเนินการสร้างทั้งหมด

2. เป้าหมายหลายรายการของกฎนี้ โดยแสดงถึงเวอร์ชันของเครื่องมือหรือชุดเครื่องมือสำหรับแพลตฟอร์มต่างๆ

3. สำหรับเป้าหมายดังกล่าวแต่ละรายการ เป็นเป้าหมายที่เชื่อมโยงของกฎ toolchain ทั่วไป เพื่อระบุข้อมูลเมตาที่เฟรมเวิร์ก Toolchain ใช้ เป้าหมาย toolchain นี้ยังหมายถึง toolchain_type ที่เชื่อมโยงกับเครื่องมือเชนนี้ด้วย ซึ่งหมายความว่ากฎ _toolchain หนึ่งๆ อาจเชื่อมโยงกับ toolchain_type ใดก็ได้ และกฎจะเชื่อมโยงกับ toolchain_type เฉพาะในอินสแตนซ์ toolchain ที่ใช้กฎ _toolchain นี้เท่านั้น

ต่อไปนี้คือคําจํากัดความของกฎ bar_toolchain สําหรับตัวอย่างที่กําลังทําอยู่ ตัวอย่างของเรามีเพียงคอมไพเลอร์ แต่เครื่องมืออื่นๆ เช่น Linker ก็จัดกลุ่มไว้ด้านล่างได้เช่นกัน

def _bar_toolchain_impl(ctx):
    toolchain_info = platform_common.ToolchainInfo(
        barcinfo = BarcInfo(
            compiler_path = ctx.attr.compiler_path,
            system_lib = ctx.attr.system_lib,
            arch_flags = ctx.attr.arch_flags,
        ),
    )
    return [toolchain_info]

bar_toolchain = rule(
    implementation = _bar_toolchain_impl,
    attrs = {
        "compiler_path": attr.string(),
        "system_lib": attr.string(),
        "arch_flags": attr.string_list(),
    },
)

กฎจะต้องแสดงผลผู้ให้บริการ ToolchainInfo ซึ่งจะกลายเป็นออบเจ็กต์ที่กฎที่ใช้ดึงข้อมูลโดยใช้ ctx.toolchains และป้ายกำกับของประเภท Toolchain ToolchainInfo เช่นเดียวกับ struct สามารถเก็บคู่ฟิลด์-ค่าแบบใดก็ได้ ควรระบุช่องที่จะเพิ่มลงใน ToolchainInfo อย่างชัดเจนที่ประเภท Toolchain ในตัวอย่างนี้ ระบบจะแสดงค่าที่รวมไว้ในออบเจ็กต์ BarcInfo เพื่อใช้สคีมาที่กําหนดไว้ข้างต้นซ้ำ สไตล์นี้อาจเป็นประโยชน์ในการตรวจสอบความถูกต้องและใช้โค้ดซ้ำ

ตอนนี้คุณกำหนดเป้าหมายสำหรับคอมไพเลอร์ barc ที่เฉพาะเจาะจงได้แล้ว

bar_toolchain(
    name = "barc_linux",
    arch_flags = [
        "--arch=Linux",
        "--debug_everything",
    ],
    compiler_path = "/path/to/barc/on/linux",
    system_lib = "/usr/lib/libbarc.so",
)

bar_toolchain(
    name = "barc_windows",
    arch_flags = [
        "--arch=Windows",
        # Different flags, no debug support on windows.
    ],
    compiler_path = "C:\\path\\on\\windows\\barc.exe",
    system_lib = "C:\\path\\on\\windows\\barclib.dll",
)

ขั้นตอนสุดท้าย คุณสร้างคำจำกัดความ toolchain สำหรับเป้าหมาย bar_toolchain 2 รายการ คําจํากัดความเหล่านี้จะลิงก์เป้าหมายเฉพาะภาษากับประเภทเครื่องมือและระบุข้อมูลข้อจํากัดที่จะบอก Bazel ว่าเครื่องมือควรใช้กับแพลตฟอร์มใด

toolchain(
    name = "barc_linux_toolchain",
    exec_compatible_with = [
        "@platforms//os:linux",
        "@platforms//cpu:x86_64",
    ],
    target_compatible_with = [
        "@platforms//os:linux",
        "@platforms//cpu:x86_64",
    ],
    toolchain = ":barc_linux",
    toolchain_type = ":toolchain_type",
)

toolchain(
    name = "barc_windows_toolchain",
    exec_compatible_with = [
        "@platforms//os:windows",
        "@platforms//cpu:x86_64",
    ],
    target_compatible_with = [
        "@platforms//os:windows",
        "@platforms//cpu:x86_64",
    ],
    toolchain = ":barc_windows",
    toolchain_type = ":toolchain_type",
)

การใช้ไวยากรณ์เส้นทางแบบสัมพัทธ์ด้านบนบ่งบอกว่าคําจํากัดความเหล่านี้ทั้งหมดอยู่ในแพ็กเกจเดียวกัน แต่ไม่มีเหตุผลที่ประเภทเครื่องมือทํางาน เป้าหมายเครื่องมือทํางานเฉพาะภาษา และเป้าหมายคําจํากัดความtoolchainจะอยู่ในแพ็กเกจแยกต่างหากไม่ได้

ดูตัวอย่างการใช้งานจริงได้ที่ go_toolchain

เชนเครื่องมือและการกำหนดค่า

คำถามสําคัญสําหรับผู้เขียนกฎคือ เมื่อวิเคราะห์เป้าหมาย bar_toolchain ระบบจะเห็นการกําหนดค่าใด และควรใช้การเปลี่ยนรูปแบบใดสําหรับทรัพยากร Dependency ตัวอย่างด้านบนใช้แอตทริบิวต์สตริง แต่จะเกิดอะไรขึ้นกับ Toolchain ที่ซับซ้อนมากขึ้นซึ่งขึ้นอยู่กับเป้าหมายอื่นๆ ในที่เก็บ Bazel

มาดู bar_toolchain เวอร์ชันที่ซับซ้อนมากขึ้นกัน

def _bar_toolchain_impl(ctx):
    # The implementation is mostly the same as above, so skipping.
    pass

bar_toolchain = rule(
    implementation = _bar_toolchain_impl,
    attrs = {
        "compiler": attr.label(
            executable = True,
            mandatory = True,
            cfg = "exec",
        ),
        "system_lib": attr.label(
            mandatory = True,
            cfg = "target",
        ),
        "arch_flags": attr.string_list(),
    },
)

การใช้ attr.label เหมือนกับกฎมาตรฐาน แต่ความหมายของพารามิเตอร์ cfg จะแตกต่างกันเล็กน้อย

Dependency จากเป้าหมาย (เรียกว่า "รายการหลัก") ไปยัง Toolchain ผ่าน Toolchain Resolution ใช้การเปลี่ยนการกำหนดค่าพิเศษที่เรียกว่า "Toolchain Revolution" การเปลี่ยน Toolchain คงการกำหนดค่าไว้เหมือนเดิม ยกเว้นแต่จะบังคับให้แพลตฟอร์มการดำเนินการสำหรับ Toolchain ของระดับบนสุดเหมือนกัน (มิฉะนั้น การแปลง Toolchain สำหรับ Toolchain อาจเลือกแพลตฟอร์มการดำเนินการใดก็ได้และไม่จำเป็นต้องเหมือนกันสำหรับแพลตฟอร์มหลัก) ซึ่งจะช่วยให้สามารถเรียกใช้exec Dependency ของ Toolchain สำหรับการดำเนินการสร้างของส่วนกลางได้ ทรัพยากร Dependency ของ Toolchain ที่ใช้ cfg = "target" (หรือที่ไม่ได้ระบุ cfg เนื่องจาก "target" เป็นค่าเริ่มต้น) จะสร้างขึ้นสำหรับแพลตฟอร์มเป้าหมายเดียวกันกับแพลตฟอร์มหลัก ซึ่งช่วยให้กฎชุดเครื่องมือสามารถนําทั้งไลบรารี (แอตทริบิวต์ system_lib ด้านบน) และเครื่องมือ (แอตทริบิวต์ compiler) ไปใช้กับกฎการสร้างที่ต้องใช้ ไลบรารีของระบบจะลิงก์กับอาร์ติแฟกต์สุดท้าย จึงต้องสร้างสำหรับแพลตฟอร์มเดียวกัน ส่วนคอมไพเลอร์เป็นเครื่องมือที่เรียกใช้ระหว่างการสร้าง และจำเป็นต้องทำงานได้บนแพลตฟอร์มการดำเนินการ

การลงทะเบียนและการสร้างด้วย Toolchain

เมื่อนำองค์ประกอบทั้งหมดมาประกอบกันแล้ว คุณเพียงแค่ต้องทำให้ Toolchain พร้อมใช้งานสำหรับขั้นตอนการแก้ปัญหาของ Bazel ซึ่งทำได้โดยการลงทะเบียนเครื่องมือทางเทคนิคในไฟล์ WORKSPACE โดยใช้ register_toolchains() หรือโดยการส่งป้ายกำกับของเครื่องมือทางเทคนิคในบรรทัดคำสั่งโดยใช้ Flag --extra_toolchains

register_toolchains(
    "//bar_tools:barc_linux_toolchain",
    "//bar_tools:barc_windows_toolchain",
    # Target patterns are also permitted, so you could have also written:
    # "//bar_tools:all",
    # or even
    # "//bar_tools/...",
)

เมื่อใช้รูปแบบเป้าหมายในการลงทะเบียน Toolchain แล้ว ลำดับการลงทะเบียน Toolchain แต่ละรายการจะกำหนดตามกฎต่อไปนี้

• Toolchain ที่กำหนดไว้ในแพ็กเกจย่อยของแพ็กเกจจะมีการลงทะเบียนก่อนtoolchain ที่กำหนดไว้ในแพ็กเกจนั้น
• ในแพ็กเกจ จะมีการลงทะเบียน Toolchain ในลำดับแบบพจนานุกรมของชื่อ

ตอนนี้เมื่อคุณสร้างเป้าหมายที่ขึ้นอยู่กับประเภท Toolchain แล้ว ระบบจะเลือก Toolchain ที่เหมาะสมตามแพลตฟอร์มเป้าหมายและการดำเนินการ

# my_pkg/BUILD

platform(
    name = "my_target_platform",
    constraint_values = [
        "@platforms//os:linux",
    ],
)

bar_binary(
    name = "my_bar_binary",
    ...
)

bazel build //my_pkg:my_bar_binary --platforms=//my_pkg:my_target_platform

Bazel จะเห็นว่า //my_pkg:my_bar_binary สร้างขึ้นด้วยแพลตฟอร์มที่มี @platforms//os:linux และจึงแก้ไขการอ้างอิง //bar_tools:toolchain_type เป็น //bar_tools:barc_linux_toolchain การดำเนินการนี้จะเป็นการสร้าง //bar_tools:barc_linux ไม่ใช่ //bar_tools:barc_windows

ความละเอียดของ Toolchain

สําหรับแต่ละเป้าหมายที่ใช้ชุดเครื่องมือ ขั้นตอนการแก้ไขชุดเครื่องมือของ Bazel จะกําหนดข้อกําหนดเฉพาะของชุดเครื่องมือของเป้าหมาย ขั้นตอนนี้จะใช้อินพุตชุดประเภท Toolchain ที่จำเป็น แพลตฟอร์มเป้าหมาย รายการแพลตฟอร์มการดำเนินการที่พร้อมใช้งาน และรายการ Toolchain ที่พร้อมใช้งาน เอาต์พุตคือเครื่องมือทางเทคนิคที่เลือกสำหรับเครื่องมือทางเทคนิคแต่ละประเภท รวมถึงแพลตฟอร์มการเรียกใช้ที่เลือกสำหรับเป้าหมายปัจจุบัน

ระบบจะรวบรวมแพลตฟอร์มการเรียกใช้และชุดเครื่องมือที่ใช้ได้จากไฟล์ WORKSPACE ผ่าน register_execution_platforms และ register_toolchains คุณยังระบุแพลตฟอร์มการเรียกใช้และชุดเครื่องมือเพิ่มเติมในบรรทัดคำสั่งผ่าน --extra_execution_platforms และ --extra_toolchains ได้ด้วย ระบบจะรวมแพลตฟอร์มโฮสต์ไว้เป็นแพลตฟอร์มการดำเนินการที่พร้อมใช้งานโดยอัตโนมัติ แพลตฟอร์มและ Toolchain ที่ใช้ได้จะได้รับการติดตามเป็นรายการตามลำดับสำหรับการกำหนดที่กำหนดโดยความต้องการ ซึ่งได้กำหนดให้กับรายการก่อนหน้าในลิสต์แล้ว

ชุดเครื่องมือทางเทคนิคที่ใช้ได้ (ตามลําดับความสําคัญ) จะสร้างขึ้นจาก --extra_toolchains และ register_toolchains ดังนี้

1. ระบบจะเพิ่มเครื่องมือที่ลงทะเบียนโดยใช้ --extra_toolchains ก่อน
   1. ภายในเครื่องมือเหล่านี้ เครื่องมือเชนสุดท้ายมีลำดับความสำคัญสูงสุด
2. Toolchains ที่ลงทะเบียนโดยใช้ register_toolchains
   1. ภายในเครื่องมือเหล่านี้ Toolchain แรกที่กล่าวถึงมีลำดับความสำคัญสูงสุด

หมายเหตุ: เป้าหมายที่ไม่ระบุตัวบุคคล เช่น :all, :* และ /... เรียงลำดับตามกลไกการโหลดแพ็กเกจของ Bazel ซึ่งใช้การจัดลำดับแบบพจนานุกรม

ขั้นตอนการแก้ปัญหามีดังนี้

1. วรรค target_compatible_with หรือ exec_compatible_with จะตรงกับแพลตฟอร์มหากแพลตฟอร์มมี constraint_value นั้นสำหรับ constraint_value แต่ละรายการในรายการด้วย (ไม่ว่าจะโดยตรงหรือเป็นค่าเริ่มต้น)

   หากแพลตฟอร์มมี constraint_value จาก constraint_setting ที่ไม่ได้อ้างอิงโดยประโยคเงื่อนไข constraint_value เหล่านี้จะไม่ส่งผลต่อการจับคู่

2. หากเป้าหมายที่สร้างระบุแอตทริบิวต์ exec_compatible_with (หรือคําจํากัดความของกฎระบุอาร์กิวเมนต์ exec_compatible_with) ระบบจะกรองรายการแพลตฟอร์มการเรียกใช้ที่ใช้ได้เพื่อนำแพลตฟอร์มที่ไม่ตรงกับข้อจำกัดการเรียกใช้ออก

3. สำหรับแพลตฟอร์มการดำเนินการแต่ละรายการที่ใช้ได้ คุณต้องเชื่อมโยง Toolchain แต่ละประเภทกับ Toolchain แรกที่มี (หากมี) ที่เข้ากันได้กับแพลตฟอร์มการดําเนินการนี้และแพลตฟอร์มเป้าหมาย

4. ตัดแพลตฟอร์มการดำเนินการที่ค้นหา Toolchain ที่บังคับซึ่งเข้ากันไม่ได้สำหรับ Toolchain ประเภทใดประเภทหนึ่งไม่ได้ ถูกตัดออก จากแพลตฟอร์มที่เหลือ แพลตฟอร์มแรกจะเป็นแพลตฟอร์มการดำเนินการของเป้าหมายปัจจุบัน และเครื่องมือเชนที่เกี่ยวข้อง (หากมี) จะกลายเป็นทรัพยากร Dependency ของเป้าหมาย

แพลตฟอร์มการดำเนินการที่เลือกจะใช้เพื่อเรียกใช้การดำเนินการทั้งหมดที่เป้าหมายสร้างขึ้น

ในกรณีที่สามารถสร้างเป้าหมายเดียวกันในการกำหนดค่าหลายรายการ (เช่น สำหรับ CPU ที่ต่างกัน) ภายในบิลด์เดียวกัน ระบบจะใช้กระบวนการแก้ปัญหาโดยไม่ขึ้นอยู่กับเป้าหมายแต่ละเวอร์ชัน

หากกฎใช้กลุ่มการดำเนินการ กลุ่มการดำเนินการแต่ละกลุ่มจะทำการแปลง Toolchain แยกกัน และแต่ละกลุ่มจะมีแพลตฟอร์มการดำเนินการและ Toolchain ของตนเอง

เครื่องมือแก้ไขข้อบกพร่อง

หากต้องการเพิ่มการรองรับเครื่องมือทางเทคนิคลงในกฎที่มีอยู่ ให้ใช้ Flag --toolchain_resolution_debug=regex ในระหว่างการแปลง Toolchain นั้น Flag จะแสดงเอาต์พุตโดยละเอียดสำหรับประเภท Toolchain หรือชื่อเป้าหมายที่ตรงกับตัวแปรนิพจน์ทั่วไป คุณใช้ .* เพื่อแสดงข้อมูลทั้งหมดได้ Bazel จะแสดงชื่อของ Toolchain ที่ตรวจสอบและข้ามในระหว่างกระบวนการแก้ไข

หากต้องการดูว่าทรัพยากร Dependency ของ cquery ใดมาจากความละเอียดของ Toolchain ให้ใช้แฟล็ก --transitions ของ cquery ดังนี้

# Find all direct dependencies of //cc:my_cc_lib. This includes explicitly
# declared dependencies, implicit dependencies, and toolchain dependencies.
$ bazel cquery 'deps(//cc:my_cc_lib, 1)'
//cc:my_cc_lib (96d6638)
@bazel_tools//tools/cpp:toolchain (96d6638)
@bazel_tools//tools/def_parser:def_parser (HOST)
//cc:my_cc_dep (96d6638)
@local_config_platform//:host (96d6638)
@bazel_tools//tools/cpp:toolchain_type (96d6638)
//:default_host_platform (96d6638)
@local_config_cc//:cc-compiler-k8 (HOST)
//cc:my_cc_lib.cc (null)
@bazel_tools//tools/cpp:grep-includes (HOST)

# Which of these are from toolchain resolution?
$ bazel cquery 'deps(//cc:my_cc_lib, 1)' --transitions=lite | grep "toolchain dependency"
  [toolchain dependency]#@local_config_cc//:cc-compiler-k8#HostTransition -> b6df211