XLA टूलिंग का इस्तेमाल करना

XLA का डेवलपमेंट वर्कफ़्लो आम तौर पर इनके बीच में होता है HLO IR, जो आइसोलेटेड फ़ंक्शन के बारे में बताती है कंप्यूटेशन की वजह से कंपाइलर को दिया जाता है. XLA के साथ कई कमांड लाइन टूल उपलब्ध हैं (नीचे बताया गया है) जो HLO का इस्तेमाल करती हैं और उसे चलाती हैं या कम्पाइलेशन स्टेज की इंटरमीडिएट. तेज़ी से काम करने के लिए, ऐसे टूल का इस्तेमाल करना बहुत फ़ायदेमंद है एचएलओ को विज़ुअलाइज़ करने के साथ-साथ, compile->modify->run बार-बार इस्तेमाल किया जा सकता है से हैक किए जा सकते हैं और उसे बार-बार बदलना और चलाना अक्सर सबसे तेज़ एक्सएलए की परफ़ॉर्मेंस या व्यवहार को समझने और उसे ठीक करने में मदद मिलती है.

XLA के साथ कंपाइल किए जा रहे किसी प्रोग्राम के लिए HLO हासिल करने का सबसे आसान तरीका है आम तौर पर, XLA_FLAGS एनवायरमेंट वैरिएबल का इस्तेमाल करता है:

$ XLA_FLAGS=--xla_dump_to=/tmp/myfolder ./myprogram-entry-point

जो ऑप्टिमाइज़ की जाने वाली सभी HLO फ़ाइलों को दिए गए फ़ोल्डर में सेव करता है मदद मिलती है.

चल रहे एचएलओ स्निपेट: run_hlo_module

run_hlo_module टूल, डिफ़ॉल्ट रूप से ऑप्टिमाइज़ेशन से पहले एचएलओ (एचएलओ) पर काम करता है बंडल कंपाइलेशन, रनिंग, और रेफ़रंस इंटरप्रेटर से तुलना लागू करना. उदाहरण के लिए, किसी इनपुट फ़ाइल को चलाने के लिए आम तौर पर शुरू किया जाने वाला इस्तेमाल NVIDIA के जीपीयू पर मौजूद computation.hlo और इसके सही होने की जांच करने के लिए:

$ run_hlo_module --platform=CUDA --reference_platform=Interpreter computation.hlo

सभी टूल की तरह ही, --help का इस्तेमाल विकल्पों की पूरी सूची पाने के लिए किया जा सकता है.

SPMD की मदद से एचएलओ स्निपेट चलाना: multihost_hlo_runner

मल्टीहोस्ट एचएलओ रनर टूल काफ़ी मिलता-जुलता है. इसमें एक चेतावनी भी है, जो एसपीएमडी, जिसमें क्रॉस होस्ट कम्यूनिकेशन भी शामिल है. यहां जाएं: ज़्यादा जानकारी के लिए, मल्टी-होस्ट एचएलओ रनर.

मल्टी-एचएलओ फिर से चलाएं

कई मॉड्यूल के साथ शुरू करने की सुविधा, run_hlo_module और hlo_runner_main का इस्तेमाल करना होता है. डंप में सभी मॉड्यूल को फिर से चलाना आसान होता है डायरेक्ट्री:

$ hlo_runner_main /dump/*before_optimizations*

एचएलओ कंपाइलेशन के मौजूदा पास/स्टेज: hlo-opt

कंपाइलर के काम को डीबग या समझने में, यह अक्सर मददगार होता है किसी खास हार्डवेयर के लिए, खास पॉइंट पर दिए गए (स्टेबल) एचएलओ के लिए पाइपलाइन (चाहे वह HLO, ऑप्टिमाइज़ की गई HLO, TritonIR या LLVM हो) इनपुट.

hlo-opt में एक से ज़्यादा आउटपुट स्टेज काम करते हैं: चाहे वह PTX हो, ऑप्टिमाइज़ेशन के बाद HLO, ऑप्टिमाइज़ेशन से पहले एलएलवीएम आईआर या ट्राइटोनआईआर. इस्तेमाल किए जा सकने वाले स्टेज का सटीक सेट अलग-अलग प्लैटफ़ॉर्म पर निर्भर करता है (जैसे कि PTX, NVIDIA के लिए खास है) और इसे --list-स्टेज्स कमांड:

$ hlo-opt --platform=CUDA --list-stages
hlo
llvm
ptx

एक स्टेज चुनने के बाद, उपयोगकर्ता किसी दिया गया प्लैटफ़ॉर्म:

$ hlo-opt myinput.hlo --platform=CUDA --stage=llvm

जो डंप को stdout (या अगर -o बताया गया था, तो दी गई फ़ाइल पर) प्रिंट करेगा.

बिना डिवाइस के इस्तेमाल करने की सुविधा

ज़्यादातर कंपाइलेशन के लिए, जीपीयू का ऐक्सेस ज़रूरी नहीं होता. इसके अलावा, कमांड लाइन पर जीपीयू की खास जानकारी, जो हमें मिल सकती है, जैसे कि ऐक्सेस के बिना PTX आउटपुट एक्सेलरेटर:

$ hlo-opt  --platform=CUDA --stage=llvm  --xla_gpu_target_config_filename=(pwd)/tools/data/gpu_specs/a100_pcie_80.txtpb input.hlo

लोकप्रिय जीपीयू की खास बातें, कंपाइलर की मदद से भेजी जाती हैं और दी गई फ़ाइल device_description.proto का स्ट्रिंग सीरियलाइज़ेशन:

gpu_device_info {
  cuda_compute_capability {
    major: 8
    minor: 0
  }
  threads_per_block_limit: 1024
  threads_per_warp: 32
  shared_memory_per_block: 127152
  shared_memory_per_core: 65536
  threads_per_core_limit: 2048
  core_count: 6192
  fpus_per_core: 64
  block_dim_limit_x: 2147483647
  block_dim_limit_y: 65535
  block_dim_limit_z: 65535
  memory_bandwidth: 2039000000000
  l2_cache_size: 4194304
  clock_rate_ghz: 1.1105
  device_memory_size: 79050250240
}
platform_name: "CUDA"

ऑटोट्यून की ज़रूरत होने पर, बिना डिवाइस के वीडियो को कंपाइल करने में समस्याएं आ सकती हैं. अच्छी बात यह है कि हम उन्हें कमांड लाइन पर भी दे सकते हैं:

$ hlo-opt  --platform=CUDA --stage=llvm  --xla_gpu_target_config_filename=gpu_specs/a100_pcie_80.txtpb --xla_gpu_load_autotune_results_from=results.textpb input.hlo

ऑटोट्यून फ़ाइल, autotune_results.proto का टेक्स्ट सीरियलाइज़ेशन है, जिसमें उदाहरण के लिए:

version: 3
results {
  device: "CUDA: 8.0, Cores: 108, GPU clock: 1.41 GHz, Memory bandwidth: 1555 GB/s, L2 cache: 40 MB"
  hlo: "{\n  tmp_0 = f16[1,16,17,3]{3,2,1,0} parameter(0)\n  tmp_1 = f16[16,51]{1,0} bitcast(f16[1,16,17,3]{3,2,1,0} tmp_0)\n  tmp_2 = s8[16,17,3]{2,1,0} parameter(1)\n  tmp_3 = s8[51,16]{0,1} bitcast(s8[16,17,3]{2,1,0} tmp_2)\n  tmp_4 = f16[51,16]{0,1} convert(s8[51,16]{0,1} tmp_3)\n  tmp_5 = f16[16,16]{1,0} dot(f16[16,51]{1,0} tmp_1, f16[51,16]{0,1} tmp_4), lhs_contracting_dims={1}, rhs_contracting_dims={0}\n  ROOT tmp_6 = f16[1,16,16]{2,1,0} bitcast(f16[16,16]{1,0} tmp_5)\n}"
  result {
    run_time {
      nanos: 31744
    }
    triton {
      block_m: 32
      block_n: 32
      block_k: 32
      split_k: 1
      num_stages: 1
      num_warps: 4
    }
  }
}

ऑटो ट्यूनिंग डेटाबेस को इनका इस्तेमाल करके क्रम से लगाया जा सकता है XLA_FLAGS=--xla_gpu_dump_autotune_results_t=<myfile.pbtxt>

सिंगल कंपाइलर पास चलाना

XLA_FLAGS के फ़्लैग भी काम करते हैं, इसलिए टूल का इस्तेमाल करके जांच की जा सकती है सिंगल पास इस्तेमाल करने का तरीका:

$ hlo-opt --platform=CUDA --stage=hlo --xla-hlo-enable-passes-only=algebraic_simplifer input.hlo